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/expressions/ExpressionUtil.java | ExpressionUtil.reduce | public static boolean reduce(AbstractExpression expr, Predicate<AbstractExpression> pred) {
final boolean current = pred.test(expr);
if (current) {
return true;
} else if (expr == null) {
return pred.test(null);
} else {
return pred.test(expr.getLeft()) || pred.test(expr.getRight()) ||
expr.getArgs() != null && expr.getArgs().stream().anyMatch(pred);
}
} | java | public static boolean reduce(AbstractExpression expr, Predicate<AbstractExpression> pred) {
final boolean current = pred.test(expr);
if (current) {
return true;
} else if (expr == null) {
return pred.test(null);
} else {
return pred.test(expr.getLeft()) || pred.test(expr.getRight()) ||
expr.getArgs() != null && expr.getArgs().stream().anyMatch(pred);
}
} | [
"public",
"static",
"boolean",
"reduce",
"(",
"AbstractExpression",
"expr",
",",
"Predicate",
"<",
"AbstractExpression",
">",
"pred",
")",
"{",
"final",
"boolean",
"current",
"=",
"pred",
".",
"test",
"(",
"expr",
")",
";",
"if",
"(",
"current",
")",
"{",
... | Check if any node of given expression tree satisfies given predicate
@param expr source expression tree
@param pred predicate to check against any expression node to find if any node satisfies.
Note that it should be able to handle null.
@return true if there exists a node that satisfies the predicate | [
"Check",
"if",
"any",
"node",
"of",
"given",
"expression",
"tree",
"satisfies",
"given",
"predicate"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/expressions/ExpressionUtil.java#L311-L322 | train |
VoltDB/voltdb | src/frontend/org/voltdb/expressions/ExpressionUtil.java | ExpressionUtil.uncombineAny | public static Collection<AbstractExpression> uncombineAny(AbstractExpression expr)
{
ArrayDeque<AbstractExpression> out = new ArrayDeque<AbstractExpression>();
if (expr != null) {
ArrayDeque<AbstractExpression> in = new ArrayDeque<AbstractExpression>();
// this chunk of code breaks the code into a list of expression that
// all have to be true for the where clause to be true
in.add(expr);
AbstractExpression inExpr = null;
while ((inExpr = in.poll()) != null) {
if (inExpr.getExpressionType() == ExpressionType.CONJUNCTION_AND) {
in.add(inExpr.getLeft());
in.add(inExpr.getRight());
}
else {
out.add(inExpr);
}
}
}
return out;
} | java | public static Collection<AbstractExpression> uncombineAny(AbstractExpression expr)
{
ArrayDeque<AbstractExpression> out = new ArrayDeque<AbstractExpression>();
if (expr != null) {
ArrayDeque<AbstractExpression> in = new ArrayDeque<AbstractExpression>();
// this chunk of code breaks the code into a list of expression that
// all have to be true for the where clause to be true
in.add(expr);
AbstractExpression inExpr = null;
while ((inExpr = in.poll()) != null) {
if (inExpr.getExpressionType() == ExpressionType.CONJUNCTION_AND) {
in.add(inExpr.getLeft());
in.add(inExpr.getRight());
}
else {
out.add(inExpr);
}
}
}
return out;
} | [
"public",
"static",
"Collection",
"<",
"AbstractExpression",
">",
"uncombineAny",
"(",
"AbstractExpression",
"expr",
")",
"{",
"ArrayDeque",
"<",
"AbstractExpression",
">",
"out",
"=",
"new",
"ArrayDeque",
"<",
"AbstractExpression",
">",
"(",
")",
";",
"if",
"("... | Convert one or more predicates, potentially in an arbitrarily nested conjunction tree
into a flattened collection. Similar to uncombine but for arbitrary tree shapes and with no
guarantee of the result collection type or of any ordering within the collection.
In fact, it currently fills an ArrayDeque via a left=to-right breadth first traversal,
but for no particular reason, so that's all subject to change.
@param expr
@return a Collection containing expr or if expr is a conjunction, its top-level non-conjunction
child expressions. | [
"Convert",
"one",
"or",
"more",
"predicates",
"potentially",
"in",
"an",
"arbitrarily",
"nested",
"conjunction",
"tree",
"into",
"a",
"flattened",
"collection",
".",
"Similar",
"to",
"uncombine",
"but",
"for",
"arbitrary",
"tree",
"shapes",
"and",
"with",
"no",
... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/expressions/ExpressionUtil.java#L442-L462 | train |
VoltDB/voltdb | src/frontend/org/voltdb/expressions/ExpressionUtil.java | ExpressionUtil.getTupleValueExpressions | public static List<TupleValueExpression>
getTupleValueExpressions(AbstractExpression input)
{
ArrayList<TupleValueExpression> tves =
new ArrayList<TupleValueExpression>();
// recursive stopping steps
if (input == null)
{
return tves;
} else if (input instanceof TupleValueExpression) {
tves.add((TupleValueExpression) input);
return tves;
}
// recursive calls
tves.addAll(getTupleValueExpressions(input.m_left));
tves.addAll(getTupleValueExpressions(input.m_right));
if (input.m_args != null) {
for (AbstractExpression argument : input.m_args) {
tves.addAll(getTupleValueExpressions(argument));
}
}
return tves;
} | java | public static List<TupleValueExpression>
getTupleValueExpressions(AbstractExpression input)
{
ArrayList<TupleValueExpression> tves =
new ArrayList<TupleValueExpression>();
// recursive stopping steps
if (input == null)
{
return tves;
} else if (input instanceof TupleValueExpression) {
tves.add((TupleValueExpression) input);
return tves;
}
// recursive calls
tves.addAll(getTupleValueExpressions(input.m_left));
tves.addAll(getTupleValueExpressions(input.m_right));
if (input.m_args != null) {
for (AbstractExpression argument : input.m_args) {
tves.addAll(getTupleValueExpressions(argument));
}
}
return tves;
} | [
"public",
"static",
"List",
"<",
"TupleValueExpression",
">",
"getTupleValueExpressions",
"(",
"AbstractExpression",
"input",
")",
"{",
"ArrayList",
"<",
"TupleValueExpression",
">",
"tves",
"=",
"new",
"ArrayList",
"<",
"TupleValueExpression",
">",
"(",
")",
";",
... | Recursively walk an expression and return a list of all the tuple
value expressions it contains. | [
"Recursively",
"walk",
"an",
"expression",
"and",
"return",
"a",
"list",
"of",
"all",
"the",
"tuple",
"value",
"expressions",
"it",
"contains",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/expressions/ExpressionUtil.java#L533-L556 | train |
VoltDB/voltdb | src/frontend/org/voltdb/expressions/ExpressionUtil.java | ExpressionUtil.subqueryRequiresScalarValueExpressionFromContext | private static boolean subqueryRequiresScalarValueExpressionFromContext(AbstractExpression parentExpr) {
if (parentExpr == null) {
// No context: we are a top-level expression. E.g, an item on the
// select list. In this case, assume the expression must be scalar.
return true;
}
// Exists and comparison operators can handle non-scalar subqueries.
if (parentExpr.getExpressionType() == ExpressionType.OPERATOR_EXISTS
|| parentExpr instanceof ComparisonExpression) {
return false;
}
// There is already a ScalarValueExpression above the subquery.
if (parentExpr instanceof ScalarValueExpression) {
return false;
}
// By default, assume that the subquery must produce a single value.
return true;
} | java | private static boolean subqueryRequiresScalarValueExpressionFromContext(AbstractExpression parentExpr) {
if (parentExpr == null) {
// No context: we are a top-level expression. E.g, an item on the
// select list. In this case, assume the expression must be scalar.
return true;
}
// Exists and comparison operators can handle non-scalar subqueries.
if (parentExpr.getExpressionType() == ExpressionType.OPERATOR_EXISTS
|| parentExpr instanceof ComparisonExpression) {
return false;
}
// There is already a ScalarValueExpression above the subquery.
if (parentExpr instanceof ScalarValueExpression) {
return false;
}
// By default, assume that the subquery must produce a single value.
return true;
} | [
"private",
"static",
"boolean",
"subqueryRequiresScalarValueExpressionFromContext",
"(",
"AbstractExpression",
"parentExpr",
")",
"{",
"if",
"(",
"parentExpr",
"==",
"null",
")",
"{",
"// No context: we are a top-level expression. E.g, an item on the",
"// select list. In this ca... | Return true if we must insert a ScalarValueExpression between a subquery
and its parent expression.
@param parentExpr the parent expression of a subquery
@return true if the parent expression is not a comparison, EXISTS operator, or
a scalar value expression | [
"Return",
"true",
"if",
"we",
"must",
"insert",
"a",
"ScalarValueExpression",
"between",
"a",
"subquery",
"and",
"its",
"parent",
"expression",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/expressions/ExpressionUtil.java#L801-L821 | train |
VoltDB/voltdb | src/frontend/org/voltdb/expressions/ExpressionUtil.java | ExpressionUtil.addScalarValueExpression | private static AbstractExpression addScalarValueExpression(SelectSubqueryExpression expr) {
if (expr.getSubqueryScan().getOutputSchema().size() != 1) {
throw new PlanningErrorException("Scalar subquery can have only one output column");
}
expr.changeToScalarExprType();
AbstractExpression scalarExpr = new ScalarValueExpression();
scalarExpr.setLeft(expr);
scalarExpr.setValueType(expr.getValueType());
scalarExpr.setValueSize(expr.getValueSize());
return scalarExpr;
} | java | private static AbstractExpression addScalarValueExpression(SelectSubqueryExpression expr) {
if (expr.getSubqueryScan().getOutputSchema().size() != 1) {
throw new PlanningErrorException("Scalar subquery can have only one output column");
}
expr.changeToScalarExprType();
AbstractExpression scalarExpr = new ScalarValueExpression();
scalarExpr.setLeft(expr);
scalarExpr.setValueType(expr.getValueType());
scalarExpr.setValueSize(expr.getValueSize());
return scalarExpr;
} | [
"private",
"static",
"AbstractExpression",
"addScalarValueExpression",
"(",
"SelectSubqueryExpression",
"expr",
")",
"{",
"if",
"(",
"expr",
".",
"getSubqueryScan",
"(",
")",
".",
"getOutputSchema",
"(",
")",
".",
"size",
"(",
")",
"!=",
"1",
")",
"{",
"throw"... | Add a ScalarValueExpression on top of the SubqueryExpression
@param expr - subquery expression
@return ScalarValueExpression | [
"Add",
"a",
"ScalarValueExpression",
"on",
"top",
"of",
"the",
"SubqueryExpression"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/expressions/ExpressionUtil.java#L828-L840 | train |
VoltDB/voltdb | src/frontend/org/voltdb/PermissionValidator.java | PermissionValidator.shouldAccept | public ClientResponseImpl shouldAccept(String name, AuthSystem.AuthUser user,
final StoredProcedureInvocation task,
final Procedure catProc) {
if (user.isAuthEnabled()) {
InvocationPermissionPolicy deniedPolicy = null;
InvocationPermissionPolicy.PolicyResult res = InvocationPermissionPolicy.PolicyResult.DENY;
for (InvocationPermissionPolicy policy : m_permissionpolicies) {
res = policy.shouldAccept(user, task, catProc);
if (res == InvocationPermissionPolicy.PolicyResult.ALLOW) {
deniedPolicy = null;
break;
}
if (res == InvocationPermissionPolicy.PolicyResult.DENY) {
if (deniedPolicy == null) {
//Take first denied response only.
deniedPolicy = policy;
}
}
}
if (deniedPolicy != null) {
return deniedPolicy.getErrorResponse(user, task, catProc);
}
//We must have an explicit allow on of the policy must grant access.
assert(res == InvocationPermissionPolicy.PolicyResult.ALLOW);
return null;
}
//User authentication is disabled. (auth disabled user)
return null;
} | java | public ClientResponseImpl shouldAccept(String name, AuthSystem.AuthUser user,
final StoredProcedureInvocation task,
final Procedure catProc) {
if (user.isAuthEnabled()) {
InvocationPermissionPolicy deniedPolicy = null;
InvocationPermissionPolicy.PolicyResult res = InvocationPermissionPolicy.PolicyResult.DENY;
for (InvocationPermissionPolicy policy : m_permissionpolicies) {
res = policy.shouldAccept(user, task, catProc);
if (res == InvocationPermissionPolicy.PolicyResult.ALLOW) {
deniedPolicy = null;
break;
}
if (res == InvocationPermissionPolicy.PolicyResult.DENY) {
if (deniedPolicy == null) {
//Take first denied response only.
deniedPolicy = policy;
}
}
}
if (deniedPolicy != null) {
return deniedPolicy.getErrorResponse(user, task, catProc);
}
//We must have an explicit allow on of the policy must grant access.
assert(res == InvocationPermissionPolicy.PolicyResult.ALLOW);
return null;
}
//User authentication is disabled. (auth disabled user)
return null;
} | [
"public",
"ClientResponseImpl",
"shouldAccept",
"(",
"String",
"name",
",",
"AuthSystem",
".",
"AuthUser",
"user",
",",
"final",
"StoredProcedureInvocation",
"task",
",",
"final",
"Procedure",
"catProc",
")",
"{",
"if",
"(",
"user",
".",
"isAuthEnabled",
"(",
")... | For auth disabled user the first policy will return ALLOW breaking the loop. | [
"For",
"auth",
"disabled",
"user",
"the",
"first",
"policy",
"will",
"return",
"ALLOW",
"breaking",
"the",
"loop",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/PermissionValidator.java#L43-L71 | train |
VoltDB/voltdb | src/frontend/org/voltdb/sysprocs/UpdateLogging.java | UpdateLogging.run | @SuppressWarnings("deprecation")
public VoltTable[] run(SystemProcedureExecutionContext ctx,
String username,
String remoteHost,
String xmlConfig)
{
long oldLevels = 0;
if (ctx.isLowestSiteId()) {
// Logger level is a global property, pick the site with lowest id to do it.
hostLog.info(String.format("%s from %s changed the log4j settings", username, remoteHost));
hostLog.info(xmlConfig);
oldLevels = hostLog.getLogLevels(loggers);
}
try {
// Mimic the multi-fragment semantics as scatter-gather pattern is an overkill for this simple task.
// There are chances that some sites being interrupted and update the logging before old logger level
// being read, but the reasons we don't care because 1) it is rare and 2) it only effects when HOST
// logger being changed from higher than INFO level to INFO or lower level.
barrier.await();
} catch (InterruptedException | BrokenBarrierException dontcare) { }
VoltDB.instance().logUpdate(xmlConfig, DeprecatedProcedureAPIAccess.getVoltPrivateRealTransactionId(this),
ctx.getPaths().getVoltDBRoot());
ctx.updateBackendLogLevels();
if (ctx.isLowestSiteId()) {
long newLevels = hostLog.getLogLevels(loggers);
if (newLevels != oldLevels) {
// If HOST logger wasn't able to log before and now it can, logs the setting change event.
int index = (int)((oldLevels >> 3) & 7);
Level before = Level.values()[index];
index = (int)((newLevels >> 3) & 7);
Level after = Level.values()[index];
if (before.ordinal() > Level.INFO.ordinal() && after.ordinal() <= Level.INFO.ordinal()) {
hostLog.info(String.format("%s from %s changed the log4j settings", username, remoteHost));
hostLog.info(xmlConfig);
}
}
barrier.reset();
}
VoltTable t = new VoltTable(VoltSystemProcedure.STATUS_SCHEMA);
t.addRow(VoltSystemProcedure.STATUS_OK);
return (new VoltTable[] {t});
} | java | @SuppressWarnings("deprecation")
public VoltTable[] run(SystemProcedureExecutionContext ctx,
String username,
String remoteHost,
String xmlConfig)
{
long oldLevels = 0;
if (ctx.isLowestSiteId()) {
// Logger level is a global property, pick the site with lowest id to do it.
hostLog.info(String.format("%s from %s changed the log4j settings", username, remoteHost));
hostLog.info(xmlConfig);
oldLevels = hostLog.getLogLevels(loggers);
}
try {
// Mimic the multi-fragment semantics as scatter-gather pattern is an overkill for this simple task.
// There are chances that some sites being interrupted and update the logging before old logger level
// being read, but the reasons we don't care because 1) it is rare and 2) it only effects when HOST
// logger being changed from higher than INFO level to INFO or lower level.
barrier.await();
} catch (InterruptedException | BrokenBarrierException dontcare) { }
VoltDB.instance().logUpdate(xmlConfig, DeprecatedProcedureAPIAccess.getVoltPrivateRealTransactionId(this),
ctx.getPaths().getVoltDBRoot());
ctx.updateBackendLogLevels();
if (ctx.isLowestSiteId()) {
long newLevels = hostLog.getLogLevels(loggers);
if (newLevels != oldLevels) {
// If HOST logger wasn't able to log before and now it can, logs the setting change event.
int index = (int)((oldLevels >> 3) & 7);
Level before = Level.values()[index];
index = (int)((newLevels >> 3) & 7);
Level after = Level.values()[index];
if (before.ordinal() > Level.INFO.ordinal() && after.ordinal() <= Level.INFO.ordinal()) {
hostLog.info(String.format("%s from %s changed the log4j settings", username, remoteHost));
hostLog.info(xmlConfig);
}
}
barrier.reset();
}
VoltTable t = new VoltTable(VoltSystemProcedure.STATUS_SCHEMA);
t.addRow(VoltSystemProcedure.STATUS_OK);
return (new VoltTable[] {t});
} | [
"@",
"SuppressWarnings",
"(",
"\"deprecation\"",
")",
"public",
"VoltTable",
"[",
"]",
"run",
"(",
"SystemProcedureExecutionContext",
"ctx",
",",
"String",
"username",
",",
"String",
"remoteHost",
",",
"String",
"xmlConfig",
")",
"{",
"long",
"oldLevels",
"=",
"... | Change the operational log configuration.
@param ctx Internal parameter. Not user-accessible.
@param xmlConfig New configuration XML document.
@return Standard STATUS table. | [
"Change",
"the",
"operational",
"log",
"configuration",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/sysprocs/UpdateLogging.java#L69-L114 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/util/ZaurusChoice.java | ZaurusChoice.add | public void add(String item, String value) {
int maxChar = MaxLenInZChoice;
if (item.length() < MaxLenInZChoice) {
maxChar = item.length();
}
super.add(item.substring(0, maxChar));
values.addElement(value);
} | java | public void add(String item, String value) {
int maxChar = MaxLenInZChoice;
if (item.length() < MaxLenInZChoice) {
maxChar = item.length();
}
super.add(item.substring(0, maxChar));
values.addElement(value);
} | [
"public",
"void",
"add",
"(",
"String",
"item",
",",
"String",
"value",
")",
"{",
"int",
"maxChar",
"=",
"MaxLenInZChoice",
";",
"if",
"(",
"item",
".",
"length",
"(",
")",
"<",
"MaxLenInZChoice",
")",
"{",
"maxChar",
"=",
"item",
".",
"length",
"(",
... | restrict strings for the choice to MaxLenInZChoice characters | [
"restrict",
"strings",
"for",
"the",
"choice",
"to",
"MaxLenInZChoice",
"characters"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/util/ZaurusChoice.java#L68-L78 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/util/ZaurusChoice.java | ZaurusChoice.findValue | private int findValue(String s) {
for (int i = 0; i < values.size(); i++) {
if (s.equals(values.elementAt(i))) {
return i;
} // end of if (s.equals(values.elementAt(i)))
} // end of for (int i=0; i<values.size(); i++)
return -1;
} | java | private int findValue(String s) {
for (int i = 0; i < values.size(); i++) {
if (s.equals(values.elementAt(i))) {
return i;
} // end of if (s.equals(values.elementAt(i)))
} // end of for (int i=0; i<values.size(); i++)
return -1;
} | [
"private",
"int",
"findValue",
"(",
"String",
"s",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"values",
".",
"size",
"(",
")",
";",
"i",
"++",
")",
"{",
"if",
"(",
"s",
".",
"equals",
"(",
"values",
".",
"elementAt",
"(",
"i",... | find for a given value the index in values | [
"find",
"for",
"a",
"given",
"value",
"the",
"index",
"in",
"values"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/util/ZaurusChoice.java#L121-L130 | train |
VoltDB/voltdb | src/frontend/org/voltdb/rejoin/StreamSnapshotSink.java | StreamSnapshotSink.getNextChunk | public static ByteBuffer getNextChunk(byte[] schemaBytes, ByteBuffer buf,
CachedByteBufferAllocator resultBufferAllocator) {
buf.position(buf.position() + 4);//skip partition id
int length = schemaBytes.length + buf.remaining();
ByteBuffer outputBuffer = resultBufferAllocator.allocate(length);
outputBuffer.put(schemaBytes);
outputBuffer.put(buf);
outputBuffer.flip();
return outputBuffer;
} | java | public static ByteBuffer getNextChunk(byte[] schemaBytes, ByteBuffer buf,
CachedByteBufferAllocator resultBufferAllocator) {
buf.position(buf.position() + 4);//skip partition id
int length = schemaBytes.length + buf.remaining();
ByteBuffer outputBuffer = resultBufferAllocator.allocate(length);
outputBuffer.put(schemaBytes);
outputBuffer.put(buf);
outputBuffer.flip();
return outputBuffer;
} | [
"public",
"static",
"ByteBuffer",
"getNextChunk",
"(",
"byte",
"[",
"]",
"schemaBytes",
",",
"ByteBuffer",
"buf",
",",
"CachedByteBufferAllocator",
"resultBufferAllocator",
")",
"{",
"buf",
".",
"position",
"(",
"buf",
".",
"position",
"(",
")",
"+",
"4",
")",... | Assemble the chunk so that it can be used to construct the VoltTable that
will be passed to EE.
@param buf
@return | [
"Assemble",
"the",
"chunk",
"so",
"that",
"it",
"can",
"be",
"used",
"to",
"construct",
"the",
"VoltTable",
"that",
"will",
"be",
"passed",
"to",
"EE",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/rejoin/StreamSnapshotSink.java#L201-L212 | train |
VoltDB/voltdb | src/frontend/org/voltdb/rejoin/StreamSnapshotSink.java | StreamSnapshotSink.processMessage | private RestoreWork processMessage(DecodedContainer msg,
CachedByteBufferAllocator resultBufferAllocator) {
if (msg == null) {
return null;
}
RestoreWork restoreWork = null;
try {
if (msg.m_msgType == StreamSnapshotMessageType.FAILURE) {
VoltDB.crashLocalVoltDB("Rejoin source sent failure message.", false, null);
// for test code only
if (m_expectedEOFs.decrementAndGet() == 0) {
m_EOF = true;
}
}
else if (msg.m_msgType == StreamSnapshotMessageType.END) {
if (rejoinLog.isTraceEnabled()) {
rejoinLog.trace("Got END message " + msg.m_blockIndex + " from " +
CoreUtils.hsIdToString(msg.m_srcHSId) +
" (TargetId " + msg.m_dataTargetId + ")");
}
if (m_expectedEOFs.decrementAndGet() == 0) {
m_EOF = true;
}
}
else if (msg.m_msgType == StreamSnapshotMessageType.SCHEMA) {
rejoinLog.trace("Got SCHEMA message " + msg.m_blockIndex + " from " +
CoreUtils.hsIdToString(msg.m_srcHSId) +
" (TargetId " + msg.m_dataTargetId + ")");
ByteBuffer block = msg.m_container.b();
block.position(StreamSnapshotDataTarget.contentOffset);
byte[] schemaBytes = new byte[block.remaining()];
block.get(schemaBytes);
m_schemas.put(msg.m_tableId, schemaBytes);
}
else if (msg.m_msgType == StreamSnapshotMessageType.HASHINATOR) {
ByteBuffer block = msg.m_container.b();
block.position(StreamSnapshotDataTarget.contentOffset);
long version = block.getLong();
byte[] hashinatorConfig = new byte[block.remaining()];
block.get(hashinatorConfig);
restoreWork = new HashinatorRestoreWork(version, hashinatorConfig);
}
else {
// It's normal snapshot data afterwards
rejoinLog.trace("Got DATA message " + msg.m_blockIndex + " from " +
CoreUtils.hsIdToString(msg.m_srcHSId) +
" (TargetId " + msg.m_dataTargetId + ")");
ByteBuffer block = msg.m_container.b();
if (!m_schemas.containsKey(msg.m_tableId)) {
VoltDB.crashLocalVoltDB("No schema for table with ID " + msg.m_tableId,
false, null);
}
// Get the byte buffer ready to be consumed
block.position(StreamSnapshotDataTarget.contentOffset);
ByteBuffer nextChunk = getNextChunk(m_schemas.get(msg.m_tableId), block, resultBufferAllocator);
m_bytesReceived += nextChunk.remaining();
restoreWork = new TableRestoreWork(msg.m_tableId, nextChunk);
}
return restoreWork;
} finally {
msg.m_container.discard();
// Queue ack to this block (after the container has been discarded)
m_ack.ack(msg.m_srcHSId, msg.m_msgType == StreamSnapshotMessageType.END, msg.m_dataTargetId, msg.m_blockIndex);
}
} | java | private RestoreWork processMessage(DecodedContainer msg,
CachedByteBufferAllocator resultBufferAllocator) {
if (msg == null) {
return null;
}
RestoreWork restoreWork = null;
try {
if (msg.m_msgType == StreamSnapshotMessageType.FAILURE) {
VoltDB.crashLocalVoltDB("Rejoin source sent failure message.", false, null);
// for test code only
if (m_expectedEOFs.decrementAndGet() == 0) {
m_EOF = true;
}
}
else if (msg.m_msgType == StreamSnapshotMessageType.END) {
if (rejoinLog.isTraceEnabled()) {
rejoinLog.trace("Got END message " + msg.m_blockIndex + " from " +
CoreUtils.hsIdToString(msg.m_srcHSId) +
" (TargetId " + msg.m_dataTargetId + ")");
}
if (m_expectedEOFs.decrementAndGet() == 0) {
m_EOF = true;
}
}
else if (msg.m_msgType == StreamSnapshotMessageType.SCHEMA) {
rejoinLog.trace("Got SCHEMA message " + msg.m_blockIndex + " from " +
CoreUtils.hsIdToString(msg.m_srcHSId) +
" (TargetId " + msg.m_dataTargetId + ")");
ByteBuffer block = msg.m_container.b();
block.position(StreamSnapshotDataTarget.contentOffset);
byte[] schemaBytes = new byte[block.remaining()];
block.get(schemaBytes);
m_schemas.put(msg.m_tableId, schemaBytes);
}
else if (msg.m_msgType == StreamSnapshotMessageType.HASHINATOR) {
ByteBuffer block = msg.m_container.b();
block.position(StreamSnapshotDataTarget.contentOffset);
long version = block.getLong();
byte[] hashinatorConfig = new byte[block.remaining()];
block.get(hashinatorConfig);
restoreWork = new HashinatorRestoreWork(version, hashinatorConfig);
}
else {
// It's normal snapshot data afterwards
rejoinLog.trace("Got DATA message " + msg.m_blockIndex + " from " +
CoreUtils.hsIdToString(msg.m_srcHSId) +
" (TargetId " + msg.m_dataTargetId + ")");
ByteBuffer block = msg.m_container.b();
if (!m_schemas.containsKey(msg.m_tableId)) {
VoltDB.crashLocalVoltDB("No schema for table with ID " + msg.m_tableId,
false, null);
}
// Get the byte buffer ready to be consumed
block.position(StreamSnapshotDataTarget.contentOffset);
ByteBuffer nextChunk = getNextChunk(m_schemas.get(msg.m_tableId), block, resultBufferAllocator);
m_bytesReceived += nextChunk.remaining();
restoreWork = new TableRestoreWork(msg.m_tableId, nextChunk);
}
return restoreWork;
} finally {
msg.m_container.discard();
// Queue ack to this block (after the container has been discarded)
m_ack.ack(msg.m_srcHSId, msg.m_msgType == StreamSnapshotMessageType.END, msg.m_dataTargetId, msg.m_blockIndex);
}
} | [
"private",
"RestoreWork",
"processMessage",
"(",
"DecodedContainer",
"msg",
",",
"CachedByteBufferAllocator",
"resultBufferAllocator",
")",
"{",
"if",
"(",
"msg",
"==",
"null",
")",
"{",
"return",
"null",
";",
"}",
"RestoreWork",
"restoreWork",
"=",
"null",
";",
... | Process a message pulled off from the network thread, and discard the
container once it's processed.
@param msg A pair of <sourceHSId, blockContainer>
@return The restore work, or null if there's no data block to return
to the site. | [
"Process",
"a",
"message",
"pulled",
"off",
"from",
"the",
"network",
"thread",
"and",
"discard",
"the",
"container",
"once",
"it",
"s",
"processed",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/rejoin/StreamSnapshotSink.java#L251-L325 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/MiscUtils.java | MiscUtils.copyFile | public static void copyFile(String fromPath, String toPath) throws Exception {
File inputFile = new File(fromPath);
File outputFile = new File(toPath);
com.google_voltpatches.common.io.Files.copy(inputFile, outputFile);
} | java | public static void copyFile(String fromPath, String toPath) throws Exception {
File inputFile = new File(fromPath);
File outputFile = new File(toPath);
com.google_voltpatches.common.io.Files.copy(inputFile, outputFile);
} | [
"public",
"static",
"void",
"copyFile",
"(",
"String",
"fromPath",
",",
"String",
"toPath",
")",
"throws",
"Exception",
"{",
"File",
"inputFile",
"=",
"new",
"File",
"(",
"fromPath",
")",
";",
"File",
"outputFile",
"=",
"new",
"File",
"(",
"toPath",
")",
... | Simple code to copy a file from one place to another...
Java should have this built in... stupid java... | [
"Simple",
"code",
"to",
"copy",
"a",
"file",
"from",
"one",
"place",
"to",
"another",
"...",
"Java",
"should",
"have",
"this",
"built",
"in",
"...",
"stupid",
"java",
"..."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/MiscUtils.java#L92-L96 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/MiscUtils.java | MiscUtils.parseRevisionString | public static String parseRevisionString(String fullBuildString) {
String build = "";
// Test for SVN revision string - example: https://svn.voltdb.com/eng/trunk?revision=2352
String[] splitted = fullBuildString.split("=", 2);
if (splitted.length == 2) {
build = splitted[1].trim();
if (build.length() == 0) {
return null;
}
return build;
}
// Test for git build string - example: 2.0 voltdb-2.0-70-gb39f43e-dirty
Pattern p = Pattern.compile("-(\\d*-\\w{8}(?:-.*)?)");
Matcher m = p.matcher(fullBuildString);
if (! m.find()) {
return null;
}
build = m.group(1).trim();
if (build.length() == 0) {
return null;
}
return build;
} | java | public static String parseRevisionString(String fullBuildString) {
String build = "";
// Test for SVN revision string - example: https://svn.voltdb.com/eng/trunk?revision=2352
String[] splitted = fullBuildString.split("=", 2);
if (splitted.length == 2) {
build = splitted[1].trim();
if (build.length() == 0) {
return null;
}
return build;
}
// Test for git build string - example: 2.0 voltdb-2.0-70-gb39f43e-dirty
Pattern p = Pattern.compile("-(\\d*-\\w{8}(?:-.*)?)");
Matcher m = p.matcher(fullBuildString);
if (! m.find()) {
return null;
}
build = m.group(1).trim();
if (build.length() == 0) {
return null;
}
return build;
} | [
"public",
"static",
"String",
"parseRevisionString",
"(",
"String",
"fullBuildString",
")",
"{",
"String",
"build",
"=",
"\"\"",
";",
"// Test for SVN revision string - example: https://svn.voltdb.com/eng/trunk?revision=2352",
"String",
"[",
"]",
"splitted",
"=",
"fullBuildSt... | Check that RevisionStrings are properly formatted.
@param fullBuildString
@return build revision # (SVN), build hash (git) or null | [
"Check",
"that",
"RevisionStrings",
"are",
"properly",
"formatted",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/MiscUtils.java#L402-L427 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/MiscUtils.java | MiscUtils.parseVersionString | public static Object[] parseVersionString(String versionString) {
if (versionString == null) {
return null;
}
// check for whitespace
if (versionString.matches("\\s")) {
return null;
}
// split on the dots
String[] split = versionString.split("\\.");
if (split.length == 0) {
return null;
}
Object[] v = new Object[split.length];
int i = 0;
for (String s : split) {
try {
v[i] = Integer.parseInt(s);
} catch (NumberFormatException e) {
v[i] = s;
}
i++;
}
// check for a numeric beginning
if (v[0] instanceof Integer) {
return v;
}
else {
return null;
}
} | java | public static Object[] parseVersionString(String versionString) {
if (versionString == null) {
return null;
}
// check for whitespace
if (versionString.matches("\\s")) {
return null;
}
// split on the dots
String[] split = versionString.split("\\.");
if (split.length == 0) {
return null;
}
Object[] v = new Object[split.length];
int i = 0;
for (String s : split) {
try {
v[i] = Integer.parseInt(s);
} catch (NumberFormatException e) {
v[i] = s;
}
i++;
}
// check for a numeric beginning
if (v[0] instanceof Integer) {
return v;
}
else {
return null;
}
} | [
"public",
"static",
"Object",
"[",
"]",
"parseVersionString",
"(",
"String",
"versionString",
")",
"{",
"if",
"(",
"versionString",
"==",
"null",
")",
"{",
"return",
"null",
";",
"}",
"// check for whitespace",
"if",
"(",
"versionString",
".",
"matches",
"(",
... | Parse a version string in the form of x.y.z. It doesn't require that
there are exactly three parts in the version. Each part must be separated
by a dot.
@param versionString
@return an array of each part as integer. | [
"Parse",
"a",
"version",
"string",
"in",
"the",
"form",
"of",
"x",
".",
"y",
".",
"z",
".",
"It",
"doesn",
"t",
"require",
"that",
"there",
"are",
"exactly",
"three",
"parts",
"in",
"the",
"version",
".",
"Each",
"part",
"must",
"be",
"separated",
"b... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/MiscUtils.java#L437-L471 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/MiscUtils.java | MiscUtils.compareVersions | public static int compareVersions(Object[] left, Object[] right) {
if (left == null || right == null) {
throw new IllegalArgumentException("Invalid versions");
}
for (int i = 0; i < left.length; i++) {
// right is shorter than left and share the same prefix => left must be larger
if (right.length == i) {
return 1;
}
if (left[i] instanceof Integer) {
if (right[i] instanceof Integer) {
// compare two numbers
if (((Integer) left[i]) > ((Integer) right[i])) {
return 1;
} else if (((Integer) left[i]) < ((Integer) right[i])) {
return -1;
}
else {
continue;
}
}
else {
// numbers always greater than alphanumeric tags
return 1;
}
}
else if (right[i] instanceof Integer) {
// alphanumeric tags always less than numbers
return -1;
}
else {
// compare two alphanumeric tags lexicographically
int cmp = ((String) left[i]).compareTo((String) right[i]);
if (cmp != 0) {
return cmp;
}
else {
// two alphanumeric tags are the same... so keep comparing
continue;
}
}
}
// left is shorter than right and share the same prefix, must be less
if (left.length < right.length) {
return -1;
}
// samesies
return 0;
} | java | public static int compareVersions(Object[] left, Object[] right) {
if (left == null || right == null) {
throw new IllegalArgumentException("Invalid versions");
}
for (int i = 0; i < left.length; i++) {
// right is shorter than left and share the same prefix => left must be larger
if (right.length == i) {
return 1;
}
if (left[i] instanceof Integer) {
if (right[i] instanceof Integer) {
// compare two numbers
if (((Integer) left[i]) > ((Integer) right[i])) {
return 1;
} else if (((Integer) left[i]) < ((Integer) right[i])) {
return -1;
}
else {
continue;
}
}
else {
// numbers always greater than alphanumeric tags
return 1;
}
}
else if (right[i] instanceof Integer) {
// alphanumeric tags always less than numbers
return -1;
}
else {
// compare two alphanumeric tags lexicographically
int cmp = ((String) left[i]).compareTo((String) right[i]);
if (cmp != 0) {
return cmp;
}
else {
// two alphanumeric tags are the same... so keep comparing
continue;
}
}
}
// left is shorter than right and share the same prefix, must be less
if (left.length < right.length) {
return -1;
}
// samesies
return 0;
} | [
"public",
"static",
"int",
"compareVersions",
"(",
"Object",
"[",
"]",
"left",
",",
"Object",
"[",
"]",
"right",
")",
"{",
"if",
"(",
"left",
"==",
"null",
"||",
"right",
"==",
"null",
")",
"{",
"throw",
"new",
"IllegalArgumentException",
"(",
"\"Invalid... | Compare two versions. Version should be represented as an array of
integers.
@param left
@param right
@return -1 if left is smaller than right, 0 if they are equal, 1 if left
is greater than right. | [
"Compare",
"two",
"versions",
".",
"Version",
"should",
"be",
"represented",
"as",
"an",
"array",
"of",
"integers",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/MiscUtils.java#L482-L534 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/MiscUtils.java | MiscUtils.isPro | public static boolean isPro() {
if (m_isPro == null) {
//Allow running pro kit as community.
if (!Boolean.parseBoolean(System.getProperty("community", "false"))) {
m_isPro = ProClass.load("org.voltdb.CommandLogImpl", "Command logging", ProClass.HANDLER_IGNORE)
.hasProClass();
} else {
m_isPro = false;
}
}
return m_isPro.booleanValue();
} | java | public static boolean isPro() {
if (m_isPro == null) {
//Allow running pro kit as community.
if (!Boolean.parseBoolean(System.getProperty("community", "false"))) {
m_isPro = ProClass.load("org.voltdb.CommandLogImpl", "Command logging", ProClass.HANDLER_IGNORE)
.hasProClass();
} else {
m_isPro = false;
}
}
return m_isPro.booleanValue();
} | [
"public",
"static",
"boolean",
"isPro",
"(",
")",
"{",
"if",
"(",
"m_isPro",
"==",
"null",
")",
"{",
"//Allow running pro kit as community.",
"if",
"(",
"!",
"Boolean",
".",
"parseBoolean",
"(",
"System",
".",
"getProperty",
"(",
"\"community\"",
",",
"\"false... | check if we're running pro code | [
"check",
"if",
"we",
"re",
"running",
"pro",
"code"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/MiscUtils.java#L563-L574 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/MiscUtils.java | MiscUtils.cheesyBufferCheckSum | public static final long cheesyBufferCheckSum(ByteBuffer buffer) {
final int mypos = buffer.position();
buffer.position(0);
long checksum = 0;
if (buffer.hasArray()) {
final byte bytes[] = buffer.array();
final int end = buffer.arrayOffset() + mypos;
for (int ii = buffer.arrayOffset(); ii < end; ii++) {
checksum += bytes[ii];
}
} else {
for (int ii = 0; ii < mypos; ii++) {
checksum += buffer.get();
}
}
buffer.position(mypos);
return checksum;
} | java | public static final long cheesyBufferCheckSum(ByteBuffer buffer) {
final int mypos = buffer.position();
buffer.position(0);
long checksum = 0;
if (buffer.hasArray()) {
final byte bytes[] = buffer.array();
final int end = buffer.arrayOffset() + mypos;
for (int ii = buffer.arrayOffset(); ii < end; ii++) {
checksum += bytes[ii];
}
} else {
for (int ii = 0; ii < mypos; ii++) {
checksum += buffer.get();
}
}
buffer.position(mypos);
return checksum;
} | [
"public",
"static",
"final",
"long",
"cheesyBufferCheckSum",
"(",
"ByteBuffer",
"buffer",
")",
"{",
"final",
"int",
"mypos",
"=",
"buffer",
".",
"position",
"(",
")",
";",
"buffer",
".",
"position",
"(",
"0",
")",
";",
"long",
"checksum",
"=",
"0",
";",
... | I heart commutativity
@param buffer ByteBuffer assumed position is at end of data
@return the cheesy checksum of this VoltTable | [
"I",
"heart",
"commutativity"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/MiscUtils.java#L617-L634 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/MiscUtils.java | MiscUtils.concatAll | public static <T> T[] concatAll(final T[] empty, Iterable<T[]> arrayList) {
assert(empty.length == 0);
if (arrayList.iterator().hasNext() == false) {
return empty;
}
int len = 0;
for (T[] subArray : arrayList) {
len += subArray.length;
}
int pos = 0;
T[] result = Arrays.copyOf(empty, len);
for (T[] subArray : arrayList) {
System.arraycopy(subArray, 0, result, pos, subArray.length);
pos += subArray.length;
}
return result;
} | java | public static <T> T[] concatAll(final T[] empty, Iterable<T[]> arrayList) {
assert(empty.length == 0);
if (arrayList.iterator().hasNext() == false) {
return empty;
}
int len = 0;
for (T[] subArray : arrayList) {
len += subArray.length;
}
int pos = 0;
T[] result = Arrays.copyOf(empty, len);
for (T[] subArray : arrayList) {
System.arraycopy(subArray, 0, result, pos, subArray.length);
pos += subArray.length;
}
return result;
} | [
"public",
"static",
"<",
"T",
">",
"T",
"[",
"]",
"concatAll",
"(",
"final",
"T",
"[",
"]",
"empty",
",",
"Iterable",
"<",
"T",
"[",
"]",
">",
"arrayList",
")",
"{",
"assert",
"(",
"empty",
".",
"length",
"==",
"0",
")",
";",
"if",
"(",
"arrayL... | Concatenate an list of arrays of typed-objects
@param empty An empty array of the right type used for cloning
@param arrayList A list of arrays to concatenate.
@return The concatenated mega-array. | [
"Concatenate",
"an",
"list",
"of",
"arrays",
"of",
"typed",
"-",
"objects"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/MiscUtils.java#L664-L681 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/MiscUtils.java | MiscUtils.getMBRss | public static long getMBRss(Client client) {
assert(client != null);
long rssMax = 0;
try {
ClientResponse r = client.callProcedure("@Statistics", "MEMORY", 0);
VoltTable stats = r.getResults()[0];
stats.resetRowPosition();
while (stats.advanceRow()) {
long rss = stats.getLong("RSS") / 1024;
if (rss > rssMax) {
rssMax = rss;
}
}
return rssMax;
}
catch (Exception e) {
e.printStackTrace();
System.exit(-1);
return 0;
}
} | java | public static long getMBRss(Client client) {
assert(client != null);
long rssMax = 0;
try {
ClientResponse r = client.callProcedure("@Statistics", "MEMORY", 0);
VoltTable stats = r.getResults()[0];
stats.resetRowPosition();
while (stats.advanceRow()) {
long rss = stats.getLong("RSS") / 1024;
if (rss > rssMax) {
rssMax = rss;
}
}
return rssMax;
}
catch (Exception e) {
e.printStackTrace();
System.exit(-1);
return 0;
}
} | [
"public",
"static",
"long",
"getMBRss",
"(",
"Client",
"client",
")",
"{",
"assert",
"(",
"client",
"!=",
"null",
")",
";",
"long",
"rssMax",
"=",
"0",
";",
"try",
"{",
"ClientResponse",
"r",
"=",
"client",
".",
"callProcedure",
"(",
"\"@Statistics\"",
"... | Get the resident set size, in mb, for the voltdb server on the other end of the client.
If the client is connected to multiple servers, return the max individual rss across
the cluster. | [
"Get",
"the",
"resident",
"set",
"size",
"in",
"mb",
"for",
"the",
"voltdb",
"server",
"on",
"the",
"other",
"end",
"of",
"the",
"client",
".",
"If",
"the",
"client",
"is",
"connected",
"to",
"multiple",
"servers",
"return",
"the",
"max",
"individual",
"... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/MiscUtils.java#L700-L720 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/MiscUtils.java | MiscUtils.zipToMap | public static <K, V> Multimap<K, V> zipToMap(List<K> keys, List<V> values)
{
if (keys.isEmpty() || values.isEmpty()) {
return null;
}
Iterator<K> keyIter = keys.iterator();
Iterator<V> valueIter = values.iterator();
ArrayListMultimap<K, V> result = ArrayListMultimap.create();
while (keyIter.hasNext() && valueIter.hasNext()) {
result.put(keyIter.next(), valueIter.next());
}
// In case there are more values than keys, assign the rest of the
// values to the first key
K firstKey = keys.get(0);
while (valueIter.hasNext()) {
result.put(firstKey, valueIter.next());
}
return result;
} | java | public static <K, V> Multimap<K, V> zipToMap(List<K> keys, List<V> values)
{
if (keys.isEmpty() || values.isEmpty()) {
return null;
}
Iterator<K> keyIter = keys.iterator();
Iterator<V> valueIter = values.iterator();
ArrayListMultimap<K, V> result = ArrayListMultimap.create();
while (keyIter.hasNext() && valueIter.hasNext()) {
result.put(keyIter.next(), valueIter.next());
}
// In case there are more values than keys, assign the rest of the
// values to the first key
K firstKey = keys.get(0);
while (valueIter.hasNext()) {
result.put(firstKey, valueIter.next());
}
return result;
} | [
"public",
"static",
"<",
"K",
",",
"V",
">",
"Multimap",
"<",
"K",
",",
"V",
">",
"zipToMap",
"(",
"List",
"<",
"K",
">",
"keys",
",",
"List",
"<",
"V",
">",
"values",
")",
"{",
"if",
"(",
"keys",
".",
"isEmpty",
"(",
")",
"||",
"values",
"."... | Zip the two lists up into a multimap
@return null if one of the lists is empty | [
"Zip",
"the",
"two",
"lists",
"up",
"into",
"a",
"multimap"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/MiscUtils.java#L726-L748 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/MiscUtils.java | MiscUtils.zip | public static <K> List<K> zip(Collection<Deque<K>> stuff)
{
final List<K> result = Lists.newArrayList();
// merge the results
Iterator<Deque<K>> iter = stuff.iterator();
while (iter.hasNext()) {
final K next = iter.next().poll();
if (next != null) {
result.add(next);
} else {
iter.remove();
}
if (!iter.hasNext()) {
iter = stuff.iterator();
}
}
return result;
} | java | public static <K> List<K> zip(Collection<Deque<K>> stuff)
{
final List<K> result = Lists.newArrayList();
// merge the results
Iterator<Deque<K>> iter = stuff.iterator();
while (iter.hasNext()) {
final K next = iter.next().poll();
if (next != null) {
result.add(next);
} else {
iter.remove();
}
if (!iter.hasNext()) {
iter = stuff.iterator();
}
}
return result;
} | [
"public",
"static",
"<",
"K",
">",
"List",
"<",
"K",
">",
"zip",
"(",
"Collection",
"<",
"Deque",
"<",
"K",
">",
">",
"stuff",
")",
"{",
"final",
"List",
"<",
"K",
">",
"result",
"=",
"Lists",
".",
"newArrayList",
"(",
")",
";",
"// merge the resul... | Aggregates the elements from each of the given deque. It takes one
element from the head of each deque in each loop and put them into a
single list. This method modifies the deques in-place.
@param stuff
@return | [
"Aggregates",
"the",
"elements",
"from",
"each",
"of",
"the",
"given",
"deque",
".",
"It",
"takes",
"one",
"element",
"from",
"the",
"head",
"of",
"each",
"deque",
"in",
"each",
"loop",
"and",
"put",
"them",
"into",
"a",
"single",
"list",
".",
"This",
... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/MiscUtils.java#L757-L777 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/MiscUtils.java | MiscUtils.sortedArrayListMultimap | public static <K extends Comparable<?>, V> ListMultimap<K, V> sortedArrayListMultimap()
{
Map<K, Collection<V>> map = Maps.newTreeMap();
return Multimaps.newListMultimap(map, new Supplier<List<V>>() {
@Override
public List<V> get()
{
return Lists.newArrayList();
}
});
} | java | public static <K extends Comparable<?>, V> ListMultimap<K, V> sortedArrayListMultimap()
{
Map<K, Collection<V>> map = Maps.newTreeMap();
return Multimaps.newListMultimap(map, new Supplier<List<V>>() {
@Override
public List<V> get()
{
return Lists.newArrayList();
}
});
} | [
"public",
"static",
"<",
"K",
"extends",
"Comparable",
"<",
"?",
">",
",",
"V",
">",
"ListMultimap",
"<",
"K",
",",
"V",
">",
"sortedArrayListMultimap",
"(",
")",
"{",
"Map",
"<",
"K",
",",
"Collection",
"<",
"V",
">",
">",
"map",
"=",
"Maps",
".",... | Create an ArrayListMultimap that uses TreeMap as the container map, so order is preserved. | [
"Create",
"an",
"ArrayListMultimap",
"that",
"uses",
"TreeMap",
"as",
"the",
"container",
"map",
"so",
"order",
"is",
"preserved",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/MiscUtils.java#L782-L792 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/MiscUtils.java | MiscUtils.roundTripForCL | public static StoredProcedureInvocation roundTripForCL(StoredProcedureInvocation invocation) throws IOException
{
if (invocation.getSerializedParams() != null) {
return invocation;
}
ByteBuffer buf = ByteBuffer.allocate(invocation.getSerializedSize());
invocation.flattenToBuffer(buf);
buf.flip();
StoredProcedureInvocation rti = new StoredProcedureInvocation();
rti.initFromBuffer(buf);
return rti;
} | java | public static StoredProcedureInvocation roundTripForCL(StoredProcedureInvocation invocation) throws IOException
{
if (invocation.getSerializedParams() != null) {
return invocation;
}
ByteBuffer buf = ByteBuffer.allocate(invocation.getSerializedSize());
invocation.flattenToBuffer(buf);
buf.flip();
StoredProcedureInvocation rti = new StoredProcedureInvocation();
rti.initFromBuffer(buf);
return rti;
} | [
"public",
"static",
"StoredProcedureInvocation",
"roundTripForCL",
"(",
"StoredProcedureInvocation",
"invocation",
")",
"throws",
"IOException",
"{",
"if",
"(",
"invocation",
".",
"getSerializedParams",
"(",
")",
"!=",
"null",
")",
"{",
"return",
"invocation",
";",
... | Serialize and then deserialize an invocation so that it has serializedParams set for command logging if the
invocation is sent to a local site.
@return The round-tripped version of the invocation
@throws IOException | [
"Serialize",
"and",
"then",
"deserialize",
"an",
"invocation",
"so",
"that",
"it",
"has",
"serializedParams",
"set",
"for",
"command",
"logging",
"if",
"the",
"invocation",
"is",
"sent",
"to",
"a",
"local",
"site",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/MiscUtils.java#L800-L812 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/MiscUtils.java | MiscUtils.getBinaryPartitionKeys | public static Map<Integer, byte[]> getBinaryPartitionKeys(TheHashinator hashinator) {
Map<Integer, byte[]> partitionMap = new HashMap<>();
VoltTable partitionKeys = null;
if (hashinator == null) {
partitionKeys = TheHashinator.getPartitionKeys(VoltType.VARBINARY);
}
else {
partitionKeys = TheHashinator.getPartitionKeys(hashinator, VoltType.VARBINARY);
}
if (partitionKeys == null) {
return null;
} else {
// This is a shared resource so make a copy of the table to protect the cache copy in TheHashinator
ByteBuffer buf = ByteBuffer.allocate(partitionKeys.getSerializedSize());
partitionKeys.flattenToBuffer(buf);
buf.flip();
VoltTable keyCopy = PrivateVoltTableFactory.createVoltTableFromSharedBuffer(buf);
while (keyCopy.advanceRow()) {
partitionMap.put((int) keyCopy.getLong(0), keyCopy.getVarbinary(1));
}
}
return partitionMap;
} | java | public static Map<Integer, byte[]> getBinaryPartitionKeys(TheHashinator hashinator) {
Map<Integer, byte[]> partitionMap = new HashMap<>();
VoltTable partitionKeys = null;
if (hashinator == null) {
partitionKeys = TheHashinator.getPartitionKeys(VoltType.VARBINARY);
}
else {
partitionKeys = TheHashinator.getPartitionKeys(hashinator, VoltType.VARBINARY);
}
if (partitionKeys == null) {
return null;
} else {
// This is a shared resource so make a copy of the table to protect the cache copy in TheHashinator
ByteBuffer buf = ByteBuffer.allocate(partitionKeys.getSerializedSize());
partitionKeys.flattenToBuffer(buf);
buf.flip();
VoltTable keyCopy = PrivateVoltTableFactory.createVoltTableFromSharedBuffer(buf);
while (keyCopy.advanceRow()) {
partitionMap.put((int) keyCopy.getLong(0), keyCopy.getVarbinary(1));
}
}
return partitionMap;
} | [
"public",
"static",
"Map",
"<",
"Integer",
",",
"byte",
"[",
"]",
">",
"getBinaryPartitionKeys",
"(",
"TheHashinator",
"hashinator",
")",
"{",
"Map",
"<",
"Integer",
",",
"byte",
"[",
"]",
">",
"partitionMap",
"=",
"new",
"HashMap",
"<>",
"(",
")",
";",
... | Get VARBINARY partition keys for the specified topology.
@return A map from partition IDs to partition keys, null if failed to get the keys. | [
"Get",
"VARBINARY",
"partition",
"keys",
"for",
"the",
"specified",
"topology",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/MiscUtils.java#L1002-L1025 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/MiscUtils.java | MiscUtils.readPropertiesFromCredentials | public static Properties readPropertiesFromCredentials(String credentials) {
Properties props = new Properties();
File propFD = new File(credentials);
if (!propFD.exists() || !propFD.isFile() || !propFD.canRead()) {
throw new IllegalArgumentException("Credentials file " + credentials + " is not a read accessible file");
} else {
FileReader fr = null;
try {
fr = new FileReader(credentials);
props.load(fr);
} catch (IOException e) {
throw new IllegalArgumentException("Credential file not found or permission denied.");
}
}
return props;
} | java | public static Properties readPropertiesFromCredentials(String credentials) {
Properties props = new Properties();
File propFD = new File(credentials);
if (!propFD.exists() || !propFD.isFile() || !propFD.canRead()) {
throw new IllegalArgumentException("Credentials file " + credentials + " is not a read accessible file");
} else {
FileReader fr = null;
try {
fr = new FileReader(credentials);
props.load(fr);
} catch (IOException e) {
throw new IllegalArgumentException("Credential file not found or permission denied.");
}
}
return props;
} | [
"public",
"static",
"Properties",
"readPropertiesFromCredentials",
"(",
"String",
"credentials",
")",
"{",
"Properties",
"props",
"=",
"new",
"Properties",
"(",
")",
";",
"File",
"propFD",
"=",
"new",
"File",
"(",
"credentials",
")",
";",
"if",
"(",
"!",
"pr... | Get username and password from credentials file.
@return a Properties variable which contains username and password. | [
"Get",
"username",
"and",
"password",
"from",
"credentials",
"file",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/MiscUtils.java#L1031-L1046 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/MiscUtils.java | MiscUtils.writeDeferredSerialization | public static int writeDeferredSerialization(ByteBuffer mbuf, DeferredSerialization ds) throws IOException
{
int written = 0;
try {
final int objStartPosition = mbuf.position();
ds.serialize(mbuf);
written = mbuf.position() - objStartPosition;
} finally {
ds.cancel();
}
return written;
} | java | public static int writeDeferredSerialization(ByteBuffer mbuf, DeferredSerialization ds) throws IOException
{
int written = 0;
try {
final int objStartPosition = mbuf.position();
ds.serialize(mbuf);
written = mbuf.position() - objStartPosition;
} finally {
ds.cancel();
}
return written;
} | [
"public",
"static",
"int",
"writeDeferredSerialization",
"(",
"ByteBuffer",
"mbuf",
",",
"DeferredSerialization",
"ds",
")",
"throws",
"IOException",
"{",
"int",
"written",
"=",
"0",
";",
"try",
"{",
"final",
"int",
"objStartPosition",
"=",
"mbuf",
".",
"positio... | Serialize the deferred serializer data into byte buffer
@param mbuf ByteBuffer the buffer is written to
@param ds DeferredSerialization data writes to the byte buffer
@return size of data
@throws IOException | [
"Serialize",
"the",
"deferred",
"serializer",
"data",
"into",
"byte",
"buffer"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/MiscUtils.java#L1055-L1066 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/RowAVL.java | RowAVL.getNode | public NodeAVL getNode(int index) {
NodeAVL n = nPrimaryNode;
while (index-- > 0) {
n = n.nNext;
}
return n;
} | java | public NodeAVL getNode(int index) {
NodeAVL n = nPrimaryNode;
while (index-- > 0) {
n = n.nNext;
}
return n;
} | [
"public",
"NodeAVL",
"getNode",
"(",
"int",
"index",
")",
"{",
"NodeAVL",
"n",
"=",
"nPrimaryNode",
";",
"while",
"(",
"index",
"--",
">",
"0",
")",
"{",
"n",
"=",
"n",
".",
"nNext",
";",
"}",
"return",
"n",
";",
"}"
] | Returns the Node for a given Index, using the ordinal position of the
Index within the Table Object. | [
"Returns",
"the",
"Node",
"for",
"a",
"given",
"Index",
"using",
"the",
"ordinal",
"position",
"of",
"the",
"Index",
"within",
"the",
"Table",
"Object",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/RowAVL.java#L128-L137 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/RowAVL.java | RowAVL.getNextNode | NodeAVL getNextNode(NodeAVL n) {
if (n == null) {
n = nPrimaryNode;
} else {
n = n.nNext;
}
return n;
} | java | NodeAVL getNextNode(NodeAVL n) {
if (n == null) {
n = nPrimaryNode;
} else {
n = n.nNext;
}
return n;
} | [
"NodeAVL",
"getNextNode",
"(",
"NodeAVL",
"n",
")",
"{",
"if",
"(",
"n",
"==",
"null",
")",
"{",
"n",
"=",
"nPrimaryNode",
";",
"}",
"else",
"{",
"n",
"=",
"n",
".",
"nNext",
";",
"}",
"return",
"n",
";",
"}"
] | Returns the Node for the next Index on this database row, given the
Node for any Index. | [
"Returns",
"the",
"Node",
"for",
"the",
"next",
"Index",
"on",
"this",
"database",
"row",
"given",
"the",
"Node",
"for",
"any",
"Index",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/RowAVL.java#L143-L152 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java | DataTree.listACLEquals | private boolean listACLEquals(List<ACL> lista, List<ACL> listb) {
if (lista.size() != listb.size()) {
return false;
}
for (int i = 0; i < lista.size(); i++) {
ACL a = lista.get(i);
ACL b = listb.get(i);
if (!a.equals(b)) {
return false;
}
}
return true;
} | java | private boolean listACLEquals(List<ACL> lista, List<ACL> listb) {
if (lista.size() != listb.size()) {
return false;
}
for (int i = 0; i < lista.size(); i++) {
ACL a = lista.get(i);
ACL b = listb.get(i);
if (!a.equals(b)) {
return false;
}
}
return true;
} | [
"private",
"boolean",
"listACLEquals",
"(",
"List",
"<",
"ACL",
">",
"lista",
",",
"List",
"<",
"ACL",
">",
"listb",
")",
"{",
"if",
"(",
"lista",
".",
"size",
"(",
")",
"!=",
"listb",
".",
"size",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",... | compare two list of acls. if there elements are in the same order and the
same size then return true else return false
@param lista
the list to be compared
@param listb
the list to be compared
@return true if and only if the lists are of the same size and the
elements are in the same order in lista and listb | [
"compare",
"two",
"list",
"of",
"acls",
".",
"if",
"there",
"elements",
"are",
"in",
"the",
"same",
"order",
"and",
"the",
"same",
"size",
"then",
"return",
"true",
"else",
"return",
"false"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java#L168-L180 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java | DataTree.convertAcls | public synchronized Long convertAcls(List<ACL> acls) {
if (acls == null)
return -1L;
// get the value from the map
Long ret = aclKeyMap.get(acls);
// could not find the map
if (ret != null)
return ret;
long val = incrementIndex();
longKeyMap.put(val, acls);
aclKeyMap.put(acls, val);
return val;
} | java | public synchronized Long convertAcls(List<ACL> acls) {
if (acls == null)
return -1L;
// get the value from the map
Long ret = aclKeyMap.get(acls);
// could not find the map
if (ret != null)
return ret;
long val = incrementIndex();
longKeyMap.put(val, acls);
aclKeyMap.put(acls, val);
return val;
} | [
"public",
"synchronized",
"Long",
"convertAcls",
"(",
"List",
"<",
"ACL",
">",
"acls",
")",
"{",
"if",
"(",
"acls",
"==",
"null",
")",
"return",
"-",
"1L",
";",
"// get the value from the map",
"Long",
"ret",
"=",
"aclKeyMap",
".",
"get",
"(",
"acls",
")... | converts the list of acls to a list of longs.
@param acls
@return a list of longs that map to the acls | [
"converts",
"the",
"list",
"of",
"acls",
"to",
"a",
"list",
"of",
"longs",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java#L188-L200 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java | DataTree.convertLong | public synchronized List<ACL> convertLong(Long longVal) {
if (longVal == null)
return null;
if (longVal == -1L)
return Ids.OPEN_ACL_UNSAFE;
List<ACL> acls = longKeyMap.get(longVal);
if (acls == null) {
LOG.error("ERROR: ACL not available for long " + longVal);
throw new RuntimeException("Failed to fetch acls for " + longVal);
}
return acls;
} | java | public synchronized List<ACL> convertLong(Long longVal) {
if (longVal == null)
return null;
if (longVal == -1L)
return Ids.OPEN_ACL_UNSAFE;
List<ACL> acls = longKeyMap.get(longVal);
if (acls == null) {
LOG.error("ERROR: ACL not available for long " + longVal);
throw new RuntimeException("Failed to fetch acls for " + longVal);
}
return acls;
} | [
"public",
"synchronized",
"List",
"<",
"ACL",
">",
"convertLong",
"(",
"Long",
"longVal",
")",
"{",
"if",
"(",
"longVal",
"==",
"null",
")",
"return",
"null",
";",
"if",
"(",
"longVal",
"==",
"-",
"1L",
")",
"return",
"Ids",
".",
"OPEN_ACL_UNSAFE",
";"... | converts a list of longs to a list of acls.
@param longs
the list of longs
@return a list of ACLs that map to longs | [
"converts",
"a",
"list",
"of",
"longs",
"to",
"a",
"list",
"of",
"acls",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java#L209-L220 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java | DataTree.approximateDataSize | public long approximateDataSize() {
long result = 0;
for (Map.Entry<String, DataNode> entry : nodes.entrySet()) {
DataNode value = entry.getValue();
synchronized (value) {
result += entry.getKey().length();
result += (value.data == null ? 0
: value.data.length);
}
}
return result;
} | java | public long approximateDataSize() {
long result = 0;
for (Map.Entry<String, DataNode> entry : nodes.entrySet()) {
DataNode value = entry.getValue();
synchronized (value) {
result += entry.getKey().length();
result += (value.data == null ? 0
: value.data.length);
}
}
return result;
} | [
"public",
"long",
"approximateDataSize",
"(",
")",
"{",
"long",
"result",
"=",
"0",
";",
"for",
"(",
"Map",
".",
"Entry",
"<",
"String",
",",
"DataNode",
">",
"entry",
":",
"nodes",
".",
"entrySet",
"(",
")",
")",
"{",
"DataNode",
"value",
"=",
"entr... | Get the size of the nodes based on path and data length.
@return size of the data | [
"Get",
"the",
"size",
"of",
"the",
"nodes",
"based",
"on",
"path",
"and",
"data",
"length",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java#L256-L267 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java | DataTree.isSpecialPath | boolean isSpecialPath(String path) {
if (rootZookeeper.equals(path) || procZookeeper.equals(path)
|| quotaZookeeper.equals(path)) {
return true;
}
return false;
} | java | boolean isSpecialPath(String path) {
if (rootZookeeper.equals(path) || procZookeeper.equals(path)
|| quotaZookeeper.equals(path)) {
return true;
}
return false;
} | [
"boolean",
"isSpecialPath",
"(",
"String",
"path",
")",
"{",
"if",
"(",
"rootZookeeper",
".",
"equals",
"(",
"path",
")",
"||",
"procZookeeper",
".",
"equals",
"(",
"path",
")",
"||",
"quotaZookeeper",
".",
"equals",
"(",
"path",
")",
")",
"{",
"return",... | is the path one of the special paths owned by zookeeper.
@param path
the path to be checked
@return true if a special path. false if not. | [
"is",
"the",
"path",
"one",
"of",
"the",
"special",
"paths",
"owned",
"by",
"zookeeper",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java#L309-L315 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java | DataTree.updateCount | public void updateCount(String lastPrefix, int diff) {
String statNode = Quotas.statPath(lastPrefix);
DataNode node = nodes.get(statNode);
StatsTrack updatedStat = null;
if (node == null) {
// should not happen
LOG.error("Missing count node for stat " + statNode);
return;
}
synchronized (node) {
updatedStat = new StatsTrack(new String(node.data));
updatedStat.setCount(updatedStat.getCount() + diff);
node.data = updatedStat.toString().getBytes();
}
// now check if the counts match the quota
String quotaNode = Quotas.quotaPath(lastPrefix);
node = nodes.get(quotaNode);
StatsTrack thisStats = null;
if (node == null) {
// should not happen
LOG.error("Missing count node for quota " + quotaNode);
return;
}
synchronized (node) {
thisStats = new StatsTrack(new String(node.data));
}
if (thisStats.getCount() < updatedStat.getCount()) {
LOG
.warn("Quota exceeded: " + lastPrefix + " count="
+ updatedStat.getCount() + " limit="
+ thisStats.getCount());
}
} | java | public void updateCount(String lastPrefix, int diff) {
String statNode = Quotas.statPath(lastPrefix);
DataNode node = nodes.get(statNode);
StatsTrack updatedStat = null;
if (node == null) {
// should not happen
LOG.error("Missing count node for stat " + statNode);
return;
}
synchronized (node) {
updatedStat = new StatsTrack(new String(node.data));
updatedStat.setCount(updatedStat.getCount() + diff);
node.data = updatedStat.toString().getBytes();
}
// now check if the counts match the quota
String quotaNode = Quotas.quotaPath(lastPrefix);
node = nodes.get(quotaNode);
StatsTrack thisStats = null;
if (node == null) {
// should not happen
LOG.error("Missing count node for quota " + quotaNode);
return;
}
synchronized (node) {
thisStats = new StatsTrack(new String(node.data));
}
if (thisStats.getCount() < updatedStat.getCount()) {
LOG
.warn("Quota exceeded: " + lastPrefix + " count="
+ updatedStat.getCount() + " limit="
+ thisStats.getCount());
}
} | [
"public",
"void",
"updateCount",
"(",
"String",
"lastPrefix",
",",
"int",
"diff",
")",
"{",
"String",
"statNode",
"=",
"Quotas",
".",
"statPath",
"(",
"lastPrefix",
")",
";",
"DataNode",
"node",
"=",
"nodes",
".",
"get",
"(",
"statNode",
")",
";",
"Stats... | update the count of this stat datanode
@param lastPrefix
the path of the node that is quotaed.
@param diff
the diff to be added to the count | [
"update",
"the",
"count",
"of",
"this",
"stat",
"datanode"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java#L351-L383 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java | DataTree.deleteNode | public void deleteNode(String path, long zxid)
throws KeeperException.NoNodeException {
int lastSlash = path.lastIndexOf('/');
String parentName = path.substring(0, lastSlash);
String childName = path.substring(lastSlash + 1);
DataNode node = nodes.get(path);
if (node == null) {
throw new KeeperException.NoNodeException();
}
nodes.remove(path);
DataNode parent = nodes.get(parentName);
if (parent == null) {
throw new KeeperException.NoNodeException();
}
synchronized (parent) {
parent.removeChild(childName);
parent.stat.setCversion(parent.stat.getCversion() + 1);
parent.stat.setPzxid(zxid);
long eowner = node.stat.getEphemeralOwner();
if (eowner != 0) {
HashSet<String> nodes = ephemerals.get(eowner);
if (nodes != null) {
synchronized (nodes) {
nodes.remove(path);
}
}
}
node.parent = null;
}
if (parentName.startsWith(procZookeeper)) {
// delete the node in the trie.
if (Quotas.limitNode.equals(childName)) {
// we need to update the trie
// as well
pTrie.deletePath(parentName.substring(quotaZookeeper.length()));
}
}
// also check to update the quotas for this node
String lastPrefix = pTrie.findMaxPrefix(path);
if (!rootZookeeper.equals(lastPrefix) && !("".equals(lastPrefix))) {
// ok we have some match and need to update
updateCount(lastPrefix, -1);
int bytes = 0;
synchronized (node) {
bytes = (node.data == null ? 0 : -(node.data.length));
}
updateBytes(lastPrefix, bytes);
}
if (LOG.isTraceEnabled()) {
ZooTrace.logTraceMessage(LOG, ZooTrace.EVENT_DELIVERY_TRACE_MASK,
"dataWatches.triggerWatch " + path);
ZooTrace.logTraceMessage(LOG, ZooTrace.EVENT_DELIVERY_TRACE_MASK,
"childWatches.triggerWatch " + parentName);
}
Set<Watcher> processed = dataWatches.triggerWatch(path,
EventType.NodeDeleted);
childWatches.triggerWatch(path, EventType.NodeDeleted, processed);
childWatches.triggerWatch(parentName.equals("") ? "/" : parentName,
EventType.NodeChildrenChanged);
} | java | public void deleteNode(String path, long zxid)
throws KeeperException.NoNodeException {
int lastSlash = path.lastIndexOf('/');
String parentName = path.substring(0, lastSlash);
String childName = path.substring(lastSlash + 1);
DataNode node = nodes.get(path);
if (node == null) {
throw new KeeperException.NoNodeException();
}
nodes.remove(path);
DataNode parent = nodes.get(parentName);
if (parent == null) {
throw new KeeperException.NoNodeException();
}
synchronized (parent) {
parent.removeChild(childName);
parent.stat.setCversion(parent.stat.getCversion() + 1);
parent.stat.setPzxid(zxid);
long eowner = node.stat.getEphemeralOwner();
if (eowner != 0) {
HashSet<String> nodes = ephemerals.get(eowner);
if (nodes != null) {
synchronized (nodes) {
nodes.remove(path);
}
}
}
node.parent = null;
}
if (parentName.startsWith(procZookeeper)) {
// delete the node in the trie.
if (Quotas.limitNode.equals(childName)) {
// we need to update the trie
// as well
pTrie.deletePath(parentName.substring(quotaZookeeper.length()));
}
}
// also check to update the quotas for this node
String lastPrefix = pTrie.findMaxPrefix(path);
if (!rootZookeeper.equals(lastPrefix) && !("".equals(lastPrefix))) {
// ok we have some match and need to update
updateCount(lastPrefix, -1);
int bytes = 0;
synchronized (node) {
bytes = (node.data == null ? 0 : -(node.data.length));
}
updateBytes(lastPrefix, bytes);
}
if (LOG.isTraceEnabled()) {
ZooTrace.logTraceMessage(LOG, ZooTrace.EVENT_DELIVERY_TRACE_MASK,
"dataWatches.triggerWatch " + path);
ZooTrace.logTraceMessage(LOG, ZooTrace.EVENT_DELIVERY_TRACE_MASK,
"childWatches.triggerWatch " + parentName);
}
Set<Watcher> processed = dataWatches.triggerWatch(path,
EventType.NodeDeleted);
childWatches.triggerWatch(path, EventType.NodeDeleted, processed);
childWatches.triggerWatch(parentName.equals("") ? "/" : parentName,
EventType.NodeChildrenChanged);
} | [
"public",
"void",
"deleteNode",
"(",
"String",
"path",
",",
"long",
"zxid",
")",
"throws",
"KeeperException",
".",
"NoNodeException",
"{",
"int",
"lastSlash",
"=",
"path",
".",
"lastIndexOf",
"(",
"'",
"'",
")",
";",
"String",
"parentName",
"=",
"path",
".... | remove the path from the datatree
@param path
the path to of the node to be deleted
@param zxid
the current zxid
@throws KeeperException.NoNodeException | [
"remove",
"the",
"path",
"from",
"the",
"datatree"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java#L524-L584 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java | DataTree.getCounts | private void getCounts(String path, Counts counts) {
DataNode node = getNode(path);
if (node == null) {
return;
}
String[] children = null;
int len = 0;
synchronized (node) {
Set<String> childs = node.getChildren();
if (childs != null) {
children = childs.toArray(new String[childs.size()]);
}
len = (node.data == null ? 0 : node.data.length);
}
// add itself
counts.count += 1;
counts.bytes += len;
if (children == null || children.length == 0) {
return;
}
for (String child : children) {
getCounts(path + "/" + child, counts);
}
} | java | private void getCounts(String path, Counts counts) {
DataNode node = getNode(path);
if (node == null) {
return;
}
String[] children = null;
int len = 0;
synchronized (node) {
Set<String> childs = node.getChildren();
if (childs != null) {
children = childs.toArray(new String[childs.size()]);
}
len = (node.data == null ? 0 : node.data.length);
}
// add itself
counts.count += 1;
counts.bytes += len;
if (children == null || children.length == 0) {
return;
}
for (String child : children) {
getCounts(path + "/" + child, counts);
}
} | [
"private",
"void",
"getCounts",
"(",
"String",
"path",
",",
"Counts",
"counts",
")",
"{",
"DataNode",
"node",
"=",
"getNode",
"(",
"path",
")",
";",
"if",
"(",
"node",
"==",
"null",
")",
"{",
"return",
";",
"}",
"String",
"[",
"]",
"children",
"=",
... | this method gets the count of nodes and the bytes under a subtree
@param path
the path to be used
@param bytes
the long bytes
@param count
the int count | [
"this",
"method",
"gets",
"the",
"count",
"of",
"nodes",
"and",
"the",
"bytes",
"under",
"a",
"subtree"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java#L853-L876 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java | DataTree.updateQuotaForPath | private void updateQuotaForPath(String path) {
Counts c = new Counts();
getCounts(path, c);
StatsTrack strack = new StatsTrack();
strack.setBytes(c.bytes);
strack.setCount(c.count);
String statPath = Quotas.quotaZookeeper + path + "/" + Quotas.statNode;
DataNode node = getNode(statPath);
// it should exist
if (node == null) {
LOG.warn("Missing quota stat node " + statPath);
return;
}
synchronized (node) {
node.data = strack.toString().getBytes();
}
} | java | private void updateQuotaForPath(String path) {
Counts c = new Counts();
getCounts(path, c);
StatsTrack strack = new StatsTrack();
strack.setBytes(c.bytes);
strack.setCount(c.count);
String statPath = Quotas.quotaZookeeper + path + "/" + Quotas.statNode;
DataNode node = getNode(statPath);
// it should exist
if (node == null) {
LOG.warn("Missing quota stat node " + statPath);
return;
}
synchronized (node) {
node.data = strack.toString().getBytes();
}
} | [
"private",
"void",
"updateQuotaForPath",
"(",
"String",
"path",
")",
"{",
"Counts",
"c",
"=",
"new",
"Counts",
"(",
")",
";",
"getCounts",
"(",
"path",
",",
"c",
")",
";",
"StatsTrack",
"strack",
"=",
"new",
"StatsTrack",
"(",
")",
";",
"strack",
".",
... | update the quota for the given path
@param path
the path to be used | [
"update",
"the",
"quota",
"for",
"the",
"given",
"path"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java#L884-L900 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java | DataTree.traverseNode | private void traverseNode(String path) {
DataNode node = getNode(path);
String children[] = null;
synchronized (node) {
Set<String> childs = node.getChildren();
if (childs != null) {
children = childs.toArray(new String[childs.size()]);
}
}
if (children != null) {
if (children.length == 0) {
// this node does not have a child
// is the leaf node
// check if its the leaf node
String endString = "/" + Quotas.limitNode;
if (path.endsWith(endString)) {
// ok this is the limit node
// get the real node and update
// the count and the bytes
String realPath = path.substring(Quotas.quotaZookeeper
.length(), path.indexOf(endString));
updateQuotaForPath(realPath);
this.pTrie.addPath(realPath);
}
return;
}
for (String child : children) {
traverseNode(path + "/" + child);
}
}
} | java | private void traverseNode(String path) {
DataNode node = getNode(path);
String children[] = null;
synchronized (node) {
Set<String> childs = node.getChildren();
if (childs != null) {
children = childs.toArray(new String[childs.size()]);
}
}
if (children != null) {
if (children.length == 0) {
// this node does not have a child
// is the leaf node
// check if its the leaf node
String endString = "/" + Quotas.limitNode;
if (path.endsWith(endString)) {
// ok this is the limit node
// get the real node and update
// the count and the bytes
String realPath = path.substring(Quotas.quotaZookeeper
.length(), path.indexOf(endString));
updateQuotaForPath(realPath);
this.pTrie.addPath(realPath);
}
return;
}
for (String child : children) {
traverseNode(path + "/" + child);
}
}
} | [
"private",
"void",
"traverseNode",
"(",
"String",
"path",
")",
"{",
"DataNode",
"node",
"=",
"getNode",
"(",
"path",
")",
";",
"String",
"children",
"[",
"]",
"=",
"null",
";",
"synchronized",
"(",
"node",
")",
"{",
"Set",
"<",
"String",
">",
"childs",... | this method traverses the quota path and update the path trie and sets
@param path | [
"this",
"method",
"traverses",
"the",
"quota",
"path",
"and",
"update",
"the",
"path",
"trie",
"and",
"sets"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java#L907-L937 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java | DataTree.setupQuota | private void setupQuota() {
String quotaPath = Quotas.quotaZookeeper;
DataNode node = getNode(quotaPath);
if (node == null) {
return;
}
traverseNode(quotaPath);
} | java | private void setupQuota() {
String quotaPath = Quotas.quotaZookeeper;
DataNode node = getNode(quotaPath);
if (node == null) {
return;
}
traverseNode(quotaPath);
} | [
"private",
"void",
"setupQuota",
"(",
")",
"{",
"String",
"quotaPath",
"=",
"Quotas",
".",
"quotaZookeeper",
";",
"DataNode",
"node",
"=",
"getNode",
"(",
"quotaPath",
")",
";",
"if",
"(",
"node",
"==",
"null",
")",
"{",
"return",
";",
"}",
"traverseNode... | this method sets up the path trie and sets up stats for quota nodes | [
"this",
"method",
"sets",
"up",
"the",
"path",
"trie",
"and",
"sets",
"up",
"stats",
"for",
"quota",
"nodes"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java#L942-L949 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java | DataTree.dumpEphemerals | public void dumpEphemerals(PrintWriter pwriter) {
Set<Long> keys = ephemerals.keySet();
pwriter.println("Sessions with Ephemerals ("
+ keys.size() + "):");
for (long k : keys) {
pwriter.print("0x" + Long.toHexString(k));
pwriter.println(":");
HashSet<String> tmp = ephemerals.get(k);
synchronized (tmp) {
for (String path : tmp) {
pwriter.println("\t" + path);
}
}
}
} | java | public void dumpEphemerals(PrintWriter pwriter) {
Set<Long> keys = ephemerals.keySet();
pwriter.println("Sessions with Ephemerals ("
+ keys.size() + "):");
for (long k : keys) {
pwriter.print("0x" + Long.toHexString(k));
pwriter.println(":");
HashSet<String> tmp = ephemerals.get(k);
synchronized (tmp) {
for (String path : tmp) {
pwriter.println("\t" + path);
}
}
}
} | [
"public",
"void",
"dumpEphemerals",
"(",
"PrintWriter",
"pwriter",
")",
"{",
"Set",
"<",
"Long",
">",
"keys",
"=",
"ephemerals",
".",
"keySet",
"(",
")",
";",
"pwriter",
".",
"println",
"(",
"\"Sessions with Ephemerals (\"",
"+",
"keys",
".",
"size",
"(",
... | Write a text dump of all the ephemerals in the datatree.
@param pwriter the output to write to | [
"Write",
"a",
"text",
"dump",
"of",
"all",
"the",
"ephemerals",
"in",
"the",
"datatree",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/server/DataTree.java#L1104-L1118 | train |
VoltDB/voltdb | src/frontend/org/voltcore/zk/ZKCountdownLatch.java | ZKCountdownLatch.getCount | public int getCount() throws InterruptedException, KeeperException {
return ByteBuffer.wrap(m_zk.getData(m_path, false, null)).getInt();
} | java | public int getCount() throws InterruptedException, KeeperException {
return ByteBuffer.wrap(m_zk.getData(m_path, false, null)).getInt();
} | [
"public",
"int",
"getCount",
"(",
")",
"throws",
"InterruptedException",
",",
"KeeperException",
"{",
"return",
"ByteBuffer",
".",
"wrap",
"(",
"m_zk",
".",
"getData",
"(",
"m_path",
",",
"false",
",",
"null",
")",
")",
".",
"getInt",
"(",
")",
";",
"}"
... | Returns the current count | [
"Returns",
"the",
"current",
"count"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltcore/zk/ZKCountdownLatch.java#L63-L65 | train |
VoltDB/voltdb | src/frontend/org/voltcore/zk/ZKCountdownLatch.java | ZKCountdownLatch.isCountedDown | public boolean isCountedDown() throws InterruptedException, KeeperException {
if (countedDown) return true;
int count = ByteBuffer.wrap(m_zk.getData(m_path, false, null)).getInt();
if (count > 0) return false;
countedDown = true;
return true;
} | java | public boolean isCountedDown() throws InterruptedException, KeeperException {
if (countedDown) return true;
int count = ByteBuffer.wrap(m_zk.getData(m_path, false, null)).getInt();
if (count > 0) return false;
countedDown = true;
return true;
} | [
"public",
"boolean",
"isCountedDown",
"(",
")",
"throws",
"InterruptedException",
",",
"KeeperException",
"{",
"if",
"(",
"countedDown",
")",
"return",
"true",
";",
"int",
"count",
"=",
"ByteBuffer",
".",
"wrap",
"(",
"m_zk",
".",
"getData",
"(",
"m_path",
"... | Returns if already counted down to zero | [
"Returns",
"if",
"already",
"counted",
"down",
"to",
"zero"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltcore/zk/ZKCountdownLatch.java#L68-L74 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/parseinfo/StmtCommonTableScan.java | StmtCommonTableScan.copyTableSchemaFromShared | private void copyTableSchemaFromShared() {
for (SchemaColumn scol : m_sharedScan.getOutputSchema()) {
SchemaColumn copy = new SchemaColumn(scol.getTableName(),
getTableAlias(),
scol.getColumnName(),
scol.getColumnAlias(),
scol.getExpression(),
scol.getDifferentiator());
addOutputColumn(copy);
}
} | java | private void copyTableSchemaFromShared() {
for (SchemaColumn scol : m_sharedScan.getOutputSchema()) {
SchemaColumn copy = new SchemaColumn(scol.getTableName(),
getTableAlias(),
scol.getColumnName(),
scol.getColumnAlias(),
scol.getExpression(),
scol.getDifferentiator());
addOutputColumn(copy);
}
} | [
"private",
"void",
"copyTableSchemaFromShared",
"(",
")",
"{",
"for",
"(",
"SchemaColumn",
"scol",
":",
"m_sharedScan",
".",
"getOutputSchema",
"(",
")",
")",
"{",
"SchemaColumn",
"copy",
"=",
"new",
"SchemaColumn",
"(",
"scol",
".",
"getTableName",
"(",
")",
... | Copy the table schema from the shared part to here.
We have to repair the table aliases. | [
"Copy",
"the",
"table",
"schema",
"from",
"the",
"shared",
"part",
"to",
"here",
".",
"We",
"have",
"to",
"repair",
"the",
"table",
"aliases",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/parseinfo/StmtCommonTableScan.java#L216-L226 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/parseinfo/StmtCommonTableScan.java | StmtCommonTableScan.harmonizeOutputSchema | public void harmonizeOutputSchema() {
boolean changedCurrent;
boolean changedBase;
boolean changedRecursive = false;
NodeSchema currentSchema = getOutputSchema();
NodeSchema baseSchema = getBestCostBasePlan().rootPlanGraph.getTrueOutputSchema(false);
NodeSchema recursiveSchema
= (getBestCostRecursivePlan() == null)
? null
: getBestCostRecursivePlan().rootPlanGraph.getTrueOutputSchema(true);
// First, make the current schema
// the widest.
changedCurrent = currentSchema.harmonize(baseSchema, "Base Query");
if (recursiveSchema != null) {
// Widen the current schema to the recursive
// schema if necessary as well.
boolean changedRec = currentSchema.harmonize(recursiveSchema, "Recursive Query");
changedCurrent = changedCurrent || changedRec;
}
// Then change the base and current
// schemas.
changedBase = baseSchema.harmonize(currentSchema, "Base Query");
if (recursiveSchema != null) {
changedRecursive = recursiveSchema.harmonize(currentSchema, "Recursive Query");
}
// If we changed something, update the output schemas
// which depend on the one we changed.
if (changedBase) {
getBestCostBasePlan().rootPlanGraph.getTrueOutputSchema(true);
}
if (changedRecursive) {
getBestCostRecursivePlan().rootPlanGraph.getTrueOutputSchema(true);
}
} | java | public void harmonizeOutputSchema() {
boolean changedCurrent;
boolean changedBase;
boolean changedRecursive = false;
NodeSchema currentSchema = getOutputSchema();
NodeSchema baseSchema = getBestCostBasePlan().rootPlanGraph.getTrueOutputSchema(false);
NodeSchema recursiveSchema
= (getBestCostRecursivePlan() == null)
? null
: getBestCostRecursivePlan().rootPlanGraph.getTrueOutputSchema(true);
// First, make the current schema
// the widest.
changedCurrent = currentSchema.harmonize(baseSchema, "Base Query");
if (recursiveSchema != null) {
// Widen the current schema to the recursive
// schema if necessary as well.
boolean changedRec = currentSchema.harmonize(recursiveSchema, "Recursive Query");
changedCurrent = changedCurrent || changedRec;
}
// Then change the base and current
// schemas.
changedBase = baseSchema.harmonize(currentSchema, "Base Query");
if (recursiveSchema != null) {
changedRecursive = recursiveSchema.harmonize(currentSchema, "Recursive Query");
}
// If we changed something, update the output schemas
// which depend on the one we changed.
if (changedBase) {
getBestCostBasePlan().rootPlanGraph.getTrueOutputSchema(true);
}
if (changedRecursive) {
getBestCostRecursivePlan().rootPlanGraph.getTrueOutputSchema(true);
}
} | [
"public",
"void",
"harmonizeOutputSchema",
"(",
")",
"{",
"boolean",
"changedCurrent",
";",
"boolean",
"changedBase",
";",
"boolean",
"changedRecursive",
"=",
"false",
";",
"NodeSchema",
"currentSchema",
"=",
"getOutputSchema",
"(",
")",
";",
"NodeSchema",
"baseSche... | We have just planned the base query and perhaps
the recursive query. We need to make sure that the
output schema of the scan and the output schemas
of the base and recursive plans are all compatible.
<ol>
<li>If they have different lengths, then it is an error,
probably an internal error.</li>
<li>If they have different types, then it is ok if there
is a common type to which the two types can be converted.</li>
<li>If they have different lengths, we need to make the length
the larger of the two.</li>
</ol>
@param scan The scan to harmonize. | [
"We",
"have",
"just",
"planned",
"the",
"base",
"query",
"and",
"perhaps",
"the",
"recursive",
"query",
".",
"We",
"need",
"to",
"make",
"sure",
"that",
"the",
"output",
"schema",
"of",
"the",
"scan",
"and",
"the",
"output",
"schemas",
"of",
"the",
"base... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/parseinfo/StmtCommonTableScan.java#L244-L277 | train |
VoltDB/voltdb | third_party/java/src/com/google_voltpatches/common/util/concurrent/AbstractFuture.java | AbstractFuture.complete | private static void complete(AbstractFuture<?> future) {
boolean maskExecutorExceptions = future.maskExecutorExceptions;
Listener next = null;
outer: while (true) {
future.releaseWaiters();
// We call this before the listeners in order to avoid needing to manage a separate stack data
// structure for them.
// afterDone() should be generally fast and only used for cleanup work... but in theory can
// also be recursive and create StackOverflowErrors
future.afterDone();
// push the current set of listeners onto next
next = future.clearListeners(next);
future = null;
while (next != null) {
Listener curr = next;
next = next.next;
Runnable task = curr.task;
if (task instanceof AbstractFuture.SetFuture) {
AbstractFuture.SetFuture<?> setFuture = (AbstractFuture.SetFuture) task;
// We unwind setFuture specifically to avoid StackOverflowErrors in the case of long
// chains of SetFutures
// Handling this special case is important because there is no way to pass an executor to
// setFuture, so a user couldn't break the chain by doing this themselves. It is also
// potentially common if someone writes a recursive Futures.transformAsync transformer.
future = setFuture.owner;
if (future.value == setFuture) {
Object valueToSet = getFutureValue(setFuture.future);
if (ATOMIC_HELPER.casValue(future, setFuture, valueToSet)) {
continue outer;
}
}
// other wise the future we were trying to set is already done.
} else {
executeListener(task, curr.executor, maskExecutorExceptions);
}
}
break;
}
} | java | private static void complete(AbstractFuture<?> future) {
boolean maskExecutorExceptions = future.maskExecutorExceptions;
Listener next = null;
outer: while (true) {
future.releaseWaiters();
// We call this before the listeners in order to avoid needing to manage a separate stack data
// structure for them.
// afterDone() should be generally fast and only used for cleanup work... but in theory can
// also be recursive and create StackOverflowErrors
future.afterDone();
// push the current set of listeners onto next
next = future.clearListeners(next);
future = null;
while (next != null) {
Listener curr = next;
next = next.next;
Runnable task = curr.task;
if (task instanceof AbstractFuture.SetFuture) {
AbstractFuture.SetFuture<?> setFuture = (AbstractFuture.SetFuture) task;
// We unwind setFuture specifically to avoid StackOverflowErrors in the case of long
// chains of SetFutures
// Handling this special case is important because there is no way to pass an executor to
// setFuture, so a user couldn't break the chain by doing this themselves. It is also
// potentially common if someone writes a recursive Futures.transformAsync transformer.
future = setFuture.owner;
if (future.value == setFuture) {
Object valueToSet = getFutureValue(setFuture.future);
if (ATOMIC_HELPER.casValue(future, setFuture, valueToSet)) {
continue outer;
}
}
// other wise the future we were trying to set is already done.
} else {
executeListener(task, curr.executor, maskExecutorExceptions);
}
}
break;
}
} | [
"private",
"static",
"void",
"complete",
"(",
"AbstractFuture",
"<",
"?",
">",
"future",
")",
"{",
"boolean",
"maskExecutorExceptions",
"=",
"future",
".",
"maskExecutorExceptions",
";",
"Listener",
"next",
"=",
"null",
";",
"outer",
":",
"while",
"(",
"true",... | Unblocks all threads and runs all listeners. | [
"Unblocks",
"all",
"threads",
"and",
"runs",
"all",
"listeners",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/com/google_voltpatches/common/util/concurrent/AbstractFuture.java#L795-L833 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/common/PathTrie.java | PathTrie.addPath | public void addPath(String path) {
if (path == null) {
return;
}
String[] pathComponents = path.split("/");
TrieNode parent = rootNode;
String part = null;
if (pathComponents.length <= 1) {
throw new IllegalArgumentException("Invalid path " + path);
}
for (int i=1; i<pathComponents.length; i++) {
part = pathComponents[i];
if (parent.getChild(part) == null) {
parent.addChild(part, new TrieNode(parent));
}
parent = parent.getChild(part);
}
parent.setProperty(true);
} | java | public void addPath(String path) {
if (path == null) {
return;
}
String[] pathComponents = path.split("/");
TrieNode parent = rootNode;
String part = null;
if (pathComponents.length <= 1) {
throw new IllegalArgumentException("Invalid path " + path);
}
for (int i=1; i<pathComponents.length; i++) {
part = pathComponents[i];
if (parent.getChild(part) == null) {
parent.addChild(part, new TrieNode(parent));
}
parent = parent.getChild(part);
}
parent.setProperty(true);
} | [
"public",
"void",
"addPath",
"(",
"String",
"path",
")",
"{",
"if",
"(",
"path",
"==",
"null",
")",
"{",
"return",
";",
"}",
"String",
"[",
"]",
"pathComponents",
"=",
"path",
".",
"split",
"(",
"\"/\"",
")",
";",
"TrieNode",
"parent",
"=",
"rootNode... | add a path to the path trie
@param path | [
"add",
"a",
"path",
"to",
"the",
"path",
"trie"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/common/PathTrie.java#L197-L215 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/common/PathTrie.java | PathTrie.deletePath | public void deletePath(String path) {
if (path == null) {
return;
}
String[] pathComponents = path.split("/");
TrieNode parent = rootNode;
String part = null;
if (pathComponents.length <= 1) {
throw new IllegalArgumentException("Invalid path " + path);
}
for (int i=1; i<pathComponents.length; i++) {
part = pathComponents[i];
if (parent.getChild(part) == null) {
//the path does not exist
return;
}
parent = parent.getChild(part);
LOG.info(parent);
}
TrieNode realParent = parent.getParent();
realParent.deleteChild(part);
} | java | public void deletePath(String path) {
if (path == null) {
return;
}
String[] pathComponents = path.split("/");
TrieNode parent = rootNode;
String part = null;
if (pathComponents.length <= 1) {
throw new IllegalArgumentException("Invalid path " + path);
}
for (int i=1; i<pathComponents.length; i++) {
part = pathComponents[i];
if (parent.getChild(part) == null) {
//the path does not exist
return;
}
parent = parent.getChild(part);
LOG.info(parent);
}
TrieNode realParent = parent.getParent();
realParent.deleteChild(part);
} | [
"public",
"void",
"deletePath",
"(",
"String",
"path",
")",
"{",
"if",
"(",
"path",
"==",
"null",
")",
"{",
"return",
";",
"}",
"String",
"[",
"]",
"pathComponents",
"=",
"path",
".",
"split",
"(",
"\"/\"",
")",
";",
"TrieNode",
"parent",
"=",
"rootN... | delete a path from the trie
@param path the path to be deleted | [
"delete",
"a",
"path",
"from",
"the",
"trie"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/common/PathTrie.java#L221-L242 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/common/PathTrie.java | PathTrie.findMaxPrefix | public String findMaxPrefix(String path) {
if (path == null) {
return null;
}
if ("/".equals(path)) {
return path;
}
String[] pathComponents = path.split("/");
TrieNode parent = rootNode;
List<String> components = new ArrayList<String>();
if (pathComponents.length <= 1) {
throw new IllegalArgumentException("Invalid path " + path);
}
int i = 1;
String part = null;
StringBuilder sb = new StringBuilder();
int lastindex = -1;
while((i < pathComponents.length)) {
if (parent.getChild(pathComponents[i]) != null) {
part = pathComponents[i];
parent = parent.getChild(part);
components.add(part);
if (parent.getProperty()) {
lastindex = i-1;
}
}
else {
break;
}
i++;
}
for (int j=0; j< (lastindex+1); j++) {
sb.append("/" + components.get(j));
}
return sb.toString();
} | java | public String findMaxPrefix(String path) {
if (path == null) {
return null;
}
if ("/".equals(path)) {
return path;
}
String[] pathComponents = path.split("/");
TrieNode parent = rootNode;
List<String> components = new ArrayList<String>();
if (pathComponents.length <= 1) {
throw new IllegalArgumentException("Invalid path " + path);
}
int i = 1;
String part = null;
StringBuilder sb = new StringBuilder();
int lastindex = -1;
while((i < pathComponents.length)) {
if (parent.getChild(pathComponents[i]) != null) {
part = pathComponents[i];
parent = parent.getChild(part);
components.add(part);
if (parent.getProperty()) {
lastindex = i-1;
}
}
else {
break;
}
i++;
}
for (int j=0; j< (lastindex+1); j++) {
sb.append("/" + components.get(j));
}
return sb.toString();
} | [
"public",
"String",
"findMaxPrefix",
"(",
"String",
"path",
")",
"{",
"if",
"(",
"path",
"==",
"null",
")",
"{",
"return",
"null",
";",
"}",
"if",
"(",
"\"/\"",
".",
"equals",
"(",
"path",
")",
")",
"{",
"return",
"path",
";",
"}",
"String",
"[",
... | return the largest prefix for the input path.
@param path the input path
@return the largest prefix for the input path. | [
"return",
"the",
"largest",
"prefix",
"for",
"the",
"input",
"path",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/common/PathTrie.java#L249-L284 | train |
VoltDB/voltdb | src/frontend/org/voltdb/TableShorthand.java | TableShorthand.tableFromShorthand | public static VoltTable tableFromShorthand(String schema) {
String name = "T";
VoltTable.ColumnInfo[] columns = null;
// get a name
Matcher nameMatcher = m_namePattern.matcher(schema);
if (nameMatcher.find()) {
name = nameMatcher.group().trim();
}
// get the column schema
Matcher columnDataMatcher = m_columnsPattern.matcher(schema);
if (!columnDataMatcher.find()) {
throw new IllegalArgumentException("No column data found in shorthand");
}
String[] columnData = columnDataMatcher.group().trim().split("\\s*,\\s*");
int columnCount = columnData.length;
columns = new VoltTable.ColumnInfo[columnCount];
for (int i = 0; i < columnCount; i++) {
columns[i] = parseColumnShorthand(columnData[i], i);
}
// get the pkey
Matcher pkeyMatcher = m_pkeyPattern.matcher(schema);
int[] pkeyIndexes = new int[0]; // default no pkey
if (pkeyMatcher.find()) {
String[] pkeyColData = pkeyMatcher.group().trim().split("\\s*,\\s*");
pkeyIndexes = new int[pkeyColData.length];
for (int pkeyIndex = 0; pkeyIndex < pkeyColData.length; pkeyIndex++) {
String pkeyCol = pkeyColData[pkeyIndex];
// numeric means index of column
if (Character.isDigit(pkeyCol.charAt(0))) {
int colIndex = Integer.parseInt(pkeyCol);
pkeyIndexes[pkeyIndex] = colIndex;
}
else {
for (int colIndex = 0; colIndex < columnCount; colIndex++) {
if (columns[colIndex].name.equals(pkeyCol)) {
pkeyIndexes[pkeyIndex] = colIndex;
break;
}
}
}
}
}
// get any partitioning
Matcher partitionMatcher = m_partitionPattern.matcher(schema);
int partitionColumnIndex = -1; // default to replicated
if (partitionMatcher.find()) {
String partitionColStr = partitionMatcher.group().trim();
// numeric means index of column
if (Character.isDigit(partitionColStr.charAt(0))) {
partitionColumnIndex = Integer.parseInt(partitionColStr);
}
else {
for (int colIndex = 0; colIndex < columnCount; colIndex++) {
if (columns[colIndex].name.equals(partitionColStr)) {
partitionColumnIndex = colIndex;
break;
}
}
}
assert(partitionColumnIndex != -1) : "Regex match here means there is a partitioning column";
}
VoltTable table = new VoltTable(
new VoltTable.ExtraMetadata(name, partitionColumnIndex, pkeyIndexes, columns),
columns,
columns.length);
return table;
} | java | public static VoltTable tableFromShorthand(String schema) {
String name = "T";
VoltTable.ColumnInfo[] columns = null;
// get a name
Matcher nameMatcher = m_namePattern.matcher(schema);
if (nameMatcher.find()) {
name = nameMatcher.group().trim();
}
// get the column schema
Matcher columnDataMatcher = m_columnsPattern.matcher(schema);
if (!columnDataMatcher.find()) {
throw new IllegalArgumentException("No column data found in shorthand");
}
String[] columnData = columnDataMatcher.group().trim().split("\\s*,\\s*");
int columnCount = columnData.length;
columns = new VoltTable.ColumnInfo[columnCount];
for (int i = 0; i < columnCount; i++) {
columns[i] = parseColumnShorthand(columnData[i], i);
}
// get the pkey
Matcher pkeyMatcher = m_pkeyPattern.matcher(schema);
int[] pkeyIndexes = new int[0]; // default no pkey
if (pkeyMatcher.find()) {
String[] pkeyColData = pkeyMatcher.group().trim().split("\\s*,\\s*");
pkeyIndexes = new int[pkeyColData.length];
for (int pkeyIndex = 0; pkeyIndex < pkeyColData.length; pkeyIndex++) {
String pkeyCol = pkeyColData[pkeyIndex];
// numeric means index of column
if (Character.isDigit(pkeyCol.charAt(0))) {
int colIndex = Integer.parseInt(pkeyCol);
pkeyIndexes[pkeyIndex] = colIndex;
}
else {
for (int colIndex = 0; colIndex < columnCount; colIndex++) {
if (columns[colIndex].name.equals(pkeyCol)) {
pkeyIndexes[pkeyIndex] = colIndex;
break;
}
}
}
}
}
// get any partitioning
Matcher partitionMatcher = m_partitionPattern.matcher(schema);
int partitionColumnIndex = -1; // default to replicated
if (partitionMatcher.find()) {
String partitionColStr = partitionMatcher.group().trim();
// numeric means index of column
if (Character.isDigit(partitionColStr.charAt(0))) {
partitionColumnIndex = Integer.parseInt(partitionColStr);
}
else {
for (int colIndex = 0; colIndex < columnCount; colIndex++) {
if (columns[colIndex].name.equals(partitionColStr)) {
partitionColumnIndex = colIndex;
break;
}
}
}
assert(partitionColumnIndex != -1) : "Regex match here means there is a partitioning column";
}
VoltTable table = new VoltTable(
new VoltTable.ExtraMetadata(name, partitionColumnIndex, pkeyIndexes, columns),
columns,
columns.length);
return table;
} | [
"public",
"static",
"VoltTable",
"tableFromShorthand",
"(",
"String",
"schema",
")",
"{",
"String",
"name",
"=",
"\"T\"",
";",
"VoltTable",
".",
"ColumnInfo",
"[",
"]",
"columns",
"=",
"null",
";",
"// get a name",
"Matcher",
"nameMatcher",
"=",
"m_namePattern",... | Parse the shorthand according to the syntax as described
in the class comment. | [
"Parse",
"the",
"shorthand",
"according",
"to",
"the",
"syntax",
"as",
"described",
"in",
"the",
"class",
"comment",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/TableShorthand.java#L152-L226 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/lib/Sort.java | Sort.swap | private static void swap(Object[] w, int a, int b) {
Object t = w[a];
w[a] = w[b];
w[b] = t;
} | java | private static void swap(Object[] w, int a, int b) {
Object t = w[a];
w[a] = w[b];
w[b] = t;
} | [
"private",
"static",
"void",
"swap",
"(",
"Object",
"[",
"]",
"w",
",",
"int",
"a",
",",
"int",
"b",
")",
"{",
"Object",
"t",
"=",
"w",
"[",
"a",
"]",
";",
"w",
"[",
"a",
"]",
"=",
"w",
"[",
"b",
"]",
";",
"w",
"[",
"b",
"]",
"=",
"t",
... | Swaps the a'th and b'th elements of the specified Row array. | [
"Swaps",
"the",
"a",
"th",
"and",
"b",
"th",
"elements",
"of",
"the",
"specified",
"Row",
"array",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/lib/Sort.java#L149-L155 | train |
VoltDB/voltdb | src/frontend/org/voltdb/client/VoltBulkLoader/PerPartitionTable.java | PerPartitionTable.insertRowInTable | synchronized void insertRowInTable(final VoltBulkLoaderRow nextRow) throws InterruptedException {
m_partitionRowQueue.put(nextRow);
if (m_partitionRowQueue.size() == m_minBatchTriggerSize) {
m_es.execute(new Runnable() {
@Override
public void run() {
try {
while (m_partitionRowQueue.size() >= m_minBatchTriggerSize) {
loadTable(buildTable(), m_table);
}
} catch (Exception e) {
loaderLog.error("Failed to load batch", e);
}
}
});
}
} | java | synchronized void insertRowInTable(final VoltBulkLoaderRow nextRow) throws InterruptedException {
m_partitionRowQueue.put(nextRow);
if (m_partitionRowQueue.size() == m_minBatchTriggerSize) {
m_es.execute(new Runnable() {
@Override
public void run() {
try {
while (m_partitionRowQueue.size() >= m_minBatchTriggerSize) {
loadTable(buildTable(), m_table);
}
} catch (Exception e) {
loaderLog.error("Failed to load batch", e);
}
}
});
}
} | [
"synchronized",
"void",
"insertRowInTable",
"(",
"final",
"VoltBulkLoaderRow",
"nextRow",
")",
"throws",
"InterruptedException",
"{",
"m_partitionRowQueue",
".",
"put",
"(",
"nextRow",
")",
";",
"if",
"(",
"m_partitionRowQueue",
".",
"size",
"(",
")",
"==",
"m_min... | Synchronized so that when the a single batch is filled up, we only queue one task to
drain the queue. The task will drain the queue until it doesn't contain a single batch. | [
"Synchronized",
"so",
"that",
"when",
"the",
"a",
"single",
"batch",
"is",
"filled",
"up",
"we",
"only",
"queue",
"one",
"task",
"to",
"drain",
"the",
"queue",
".",
"The",
"task",
"will",
"drain",
"the",
"queue",
"until",
"it",
"doesn",
"t",
"contain",
... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/client/VoltBulkLoader/PerPartitionTable.java#L170-L186 | train |
VoltDB/voltdb | src/frontend/org/voltdb/CLIConfig.java | CLIConfig.getFields | public static List<Field> getFields(Class<?> startClass) {
List<Field> currentClassFields = new ArrayList<Field>();
currentClassFields.addAll(Arrays.asList(startClass.getDeclaredFields()));
Class<?> parentClass = startClass.getSuperclass();
if (parentClass != null) {
List<Field> parentClassFields = (List<Field>) getFields(parentClass);
currentClassFields.addAll(parentClassFields);
}
return currentClassFields;
} | java | public static List<Field> getFields(Class<?> startClass) {
List<Field> currentClassFields = new ArrayList<Field>();
currentClassFields.addAll(Arrays.asList(startClass.getDeclaredFields()));
Class<?> parentClass = startClass.getSuperclass();
if (parentClass != null) {
List<Field> parentClassFields = (List<Field>) getFields(parentClass);
currentClassFields.addAll(parentClassFields);
}
return currentClassFields;
} | [
"public",
"static",
"List",
"<",
"Field",
">",
"getFields",
"(",
"Class",
"<",
"?",
">",
"startClass",
")",
"{",
"List",
"<",
"Field",
">",
"currentClassFields",
"=",
"new",
"ArrayList",
"<",
"Field",
">",
"(",
")",
";",
"currentClassFields",
".",
"addAl... | get all the fields, including parents
@param startClass the current class
@return a list of fields | [
"get",
"all",
"the",
"fields",
"including",
"parents"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/CLIConfig.java#L259-L268 | train |
VoltDB/voltdb | src/frontend/org/voltdb/importer/ImportManager.java | ImportManager.initialize | public static synchronized void initialize(int myHostId, CatalogContext catalogContext, HostMessenger messenger) throws BundleException, IOException {
ImporterStatsCollector statsCollector = new ImporterStatsCollector(myHostId);
ImportManager em = new ImportManager(myHostId, messenger, statsCollector);
VoltDB.instance().getStatsAgent().registerStatsSource(
StatsSelector.IMPORTER,
myHostId,
statsCollector);
m_self = em;
em.create(catalogContext);
} | java | public static synchronized void initialize(int myHostId, CatalogContext catalogContext, HostMessenger messenger) throws BundleException, IOException {
ImporterStatsCollector statsCollector = new ImporterStatsCollector(myHostId);
ImportManager em = new ImportManager(myHostId, messenger, statsCollector);
VoltDB.instance().getStatsAgent().registerStatsSource(
StatsSelector.IMPORTER,
myHostId,
statsCollector);
m_self = em;
em.create(catalogContext);
} | [
"public",
"static",
"synchronized",
"void",
"initialize",
"(",
"int",
"myHostId",
",",
"CatalogContext",
"catalogContext",
",",
"HostMessenger",
"messenger",
")",
"throws",
"BundleException",
",",
"IOException",
"{",
"ImporterStatsCollector",
"statsCollector",
"=",
"new... | Create the singleton ImportManager and initialize.
@param myHostId my host id in cluster
@param catalogContext current catalog context
@param messenger messenger to get to ZK
@throws org.osgi.framework.BundleException
@throws java.io.IOException | [
"Create",
"the",
"singleton",
"ImportManager",
"and",
"initialize",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/importer/ImportManager.java#L112-L122 | train |
VoltDB/voltdb | src/frontend/org/voltdb/importer/ImportManager.java | ImportManager.create | private synchronized void create(CatalogContext catalogContext) {
try {
Map<String, ImportConfiguration> newProcessorConfig = loadNewConfigAndBundles(catalogContext);
restartImporters(newProcessorConfig);
} catch (final Exception e) {
VoltDB.crashLocalVoltDB("Error creating import processor", true, e);
}
} | java | private synchronized void create(CatalogContext catalogContext) {
try {
Map<String, ImportConfiguration> newProcessorConfig = loadNewConfigAndBundles(catalogContext);
restartImporters(newProcessorConfig);
} catch (final Exception e) {
VoltDB.crashLocalVoltDB("Error creating import processor", true, e);
}
} | [
"private",
"synchronized",
"void",
"create",
"(",
"CatalogContext",
"catalogContext",
")",
"{",
"try",
"{",
"Map",
"<",
"String",
",",
"ImportConfiguration",
">",
"newProcessorConfig",
"=",
"loadNewConfigAndBundles",
"(",
"catalogContext",
")",
";",
"restartImporters"... | This creates a import connector from configuration provided.
@param catalogContext | [
"This",
"creates",
"a",
"import",
"connector",
"from",
"configuration",
"provided",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/importer/ImportManager.java#L128-L135 | train |
VoltDB/voltdb | src/frontend/org/voltdb/importer/ImportManager.java | ImportManager.loadNewConfigAndBundles | private Map<String, ImportConfiguration> loadNewConfigAndBundles(CatalogContext catalogContext) {
Map<String, ImportConfiguration> newProcessorConfig;
ImportType importElement = catalogContext.getDeployment().getImport();
if (importElement == null || importElement.getConfiguration().isEmpty()) {
newProcessorConfig = new HashMap<>();
} else {
newProcessorConfig = CatalogUtil.getImportProcessorConfig(importElement);
}
Iterator<Map.Entry<String, ImportConfiguration>> iter = newProcessorConfig.entrySet().iterator();
while (iter.hasNext()) {
String configName = iter.next().getKey();
ImportConfiguration importConfig = newProcessorConfig.get(configName);
Properties properties = importConfig.getmoduleProperties();
String importBundleJar = properties.getProperty(ImportDataProcessor.IMPORT_MODULE);
Preconditions.checkNotNull(importBundleJar,
"Import source is undefined or custom import plugin class missing.");
if (!importConfig.checkProcedures(catalogContext, importLog, configName)) {
iter.remove();
continue;
}
// NOTE: if bundle is already loaded, loadImporterBundle does nothing and returns true
boolean bundlePresent = loadImporterBundle(properties);
if (!bundlePresent) {
iter.remove();
}
}
m_formatterFactories.clear();
for (ImportConfiguration config : newProcessorConfig.values()) {
Map<String, FormatterBuilder> formatters = config.getFormatterBuilders();
if (formatters != null) {
try {
for (FormatterBuilder builder : formatters.values()) {
String module = builder.getFormatterProperties().getProperty(ImportDataProcessor.IMPORT_FORMATTER);
AbstractFormatterFactory formatterFactory = m_formatterFactories.get(module);
if (formatterFactory == null) {
URI moduleURI = URI.create(module);
formatterFactory = m_moduleManager.getService(moduleURI, AbstractFormatterFactory.class);
if (formatterFactory == null) {
VoltDB.crashLocalVoltDB("Failed to initialize formatter from: " + module);
}
m_formatterFactories.put(module, formatterFactory);
}
builder.setFormatterFactory(formatterFactory);
}
} catch(Throwable t) {
VoltDB.crashLocalVoltDB("Failed to initialize formatter.");
}
}
}
importLog.info("Final importer count:" + newProcessorConfig.size());
return newProcessorConfig;
} | java | private Map<String, ImportConfiguration> loadNewConfigAndBundles(CatalogContext catalogContext) {
Map<String, ImportConfiguration> newProcessorConfig;
ImportType importElement = catalogContext.getDeployment().getImport();
if (importElement == null || importElement.getConfiguration().isEmpty()) {
newProcessorConfig = new HashMap<>();
} else {
newProcessorConfig = CatalogUtil.getImportProcessorConfig(importElement);
}
Iterator<Map.Entry<String, ImportConfiguration>> iter = newProcessorConfig.entrySet().iterator();
while (iter.hasNext()) {
String configName = iter.next().getKey();
ImportConfiguration importConfig = newProcessorConfig.get(configName);
Properties properties = importConfig.getmoduleProperties();
String importBundleJar = properties.getProperty(ImportDataProcessor.IMPORT_MODULE);
Preconditions.checkNotNull(importBundleJar,
"Import source is undefined or custom import plugin class missing.");
if (!importConfig.checkProcedures(catalogContext, importLog, configName)) {
iter.remove();
continue;
}
// NOTE: if bundle is already loaded, loadImporterBundle does nothing and returns true
boolean bundlePresent = loadImporterBundle(properties);
if (!bundlePresent) {
iter.remove();
}
}
m_formatterFactories.clear();
for (ImportConfiguration config : newProcessorConfig.values()) {
Map<String, FormatterBuilder> formatters = config.getFormatterBuilders();
if (formatters != null) {
try {
for (FormatterBuilder builder : formatters.values()) {
String module = builder.getFormatterProperties().getProperty(ImportDataProcessor.IMPORT_FORMATTER);
AbstractFormatterFactory formatterFactory = m_formatterFactories.get(module);
if (formatterFactory == null) {
URI moduleURI = URI.create(module);
formatterFactory = m_moduleManager.getService(moduleURI, AbstractFormatterFactory.class);
if (formatterFactory == null) {
VoltDB.crashLocalVoltDB("Failed to initialize formatter from: " + module);
}
m_formatterFactories.put(module, formatterFactory);
}
builder.setFormatterFactory(formatterFactory);
}
} catch(Throwable t) {
VoltDB.crashLocalVoltDB("Failed to initialize formatter.");
}
}
}
importLog.info("Final importer count:" + newProcessorConfig.size());
return newProcessorConfig;
} | [
"private",
"Map",
"<",
"String",
",",
"ImportConfiguration",
">",
"loadNewConfigAndBundles",
"(",
"CatalogContext",
"catalogContext",
")",
"{",
"Map",
"<",
"String",
",",
"ImportConfiguration",
">",
"newProcessorConfig",
";",
"ImportType",
"importElement",
"=",
"catal... | Parses importer configs and loads the formatters and bundles needed into memory.
This is used to generate a new configuration either to load or to compare with existing.
@param catalogContext new catalog context
@return new importer configuration | [
"Parses",
"importer",
"configs",
"and",
"loads",
"the",
"formatters",
"and",
"bundles",
"needed",
"into",
"memory",
".",
"This",
"is",
"used",
"to",
"generate",
"a",
"new",
"configuration",
"either",
"to",
"load",
"or",
"to",
"compare",
"with",
"existing",
"... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/importer/ImportManager.java#L161-L216 | train |
VoltDB/voltdb | src/frontend/org/voltdb/importer/ImportManager.java | ImportManager.loadImporterBundle | private boolean loadImporterBundle(Properties moduleProperties){
String importModuleName = moduleProperties.getProperty(ImportDataProcessor.IMPORT_MODULE);
String attrs[] = importModuleName.split("\\|");
String bundleJar = attrs[1];
String moduleType = attrs[0];
try {
AbstractImporterFactory importerFactory = m_loadedBundles.get(bundleJar);
if (importerFactory == null) {
if (moduleType.equalsIgnoreCase("osgi")) {
URI bundleURI = URI.create(bundleJar);
importerFactory = m_moduleManager.getService(bundleURI, AbstractImporterFactory.class);
if (importerFactory == null) {
importLog.error("Failed to initialize importer from: " + bundleJar);
return false;
}
} else {
// class based importer.
Class<?> reference = this.getClass().getClassLoader().loadClass(bundleJar);
if (reference == null) {
importLog.error("Failed to initialize importer from: " + bundleJar);
return false;
}
importerFactory = (AbstractImporterFactory)reference.newInstance();
}
String importerType = importerFactory.getTypeName();
if (importerType == null || importerType.trim().isEmpty()) {
throw new RuntimeException("Importer must implement and return a valid unique name.");
}
Preconditions.checkState(!m_importersByType.containsKey(importerType),
"Importer must implement and return a valid unique name: " + importerType);
m_importersByType.put(importerType, importerFactory);
m_loadedBundles.put(bundleJar, importerFactory);
}
} catch(Throwable t) {
importLog.error("Failed to configure import handler for " + bundleJar, t);
Throwables.propagate(t);
}
return true;
} | java | private boolean loadImporterBundle(Properties moduleProperties){
String importModuleName = moduleProperties.getProperty(ImportDataProcessor.IMPORT_MODULE);
String attrs[] = importModuleName.split("\\|");
String bundleJar = attrs[1];
String moduleType = attrs[0];
try {
AbstractImporterFactory importerFactory = m_loadedBundles.get(bundleJar);
if (importerFactory == null) {
if (moduleType.equalsIgnoreCase("osgi")) {
URI bundleURI = URI.create(bundleJar);
importerFactory = m_moduleManager.getService(bundleURI, AbstractImporterFactory.class);
if (importerFactory == null) {
importLog.error("Failed to initialize importer from: " + bundleJar);
return false;
}
} else {
// class based importer.
Class<?> reference = this.getClass().getClassLoader().loadClass(bundleJar);
if (reference == null) {
importLog.error("Failed to initialize importer from: " + bundleJar);
return false;
}
importerFactory = (AbstractImporterFactory)reference.newInstance();
}
String importerType = importerFactory.getTypeName();
if (importerType == null || importerType.trim().isEmpty()) {
throw new RuntimeException("Importer must implement and return a valid unique name.");
}
Preconditions.checkState(!m_importersByType.containsKey(importerType),
"Importer must implement and return a valid unique name: " + importerType);
m_importersByType.put(importerType, importerFactory);
m_loadedBundles.put(bundleJar, importerFactory);
}
} catch(Throwable t) {
importLog.error("Failed to configure import handler for " + bundleJar, t);
Throwables.propagate(t);
}
return true;
} | [
"private",
"boolean",
"loadImporterBundle",
"(",
"Properties",
"moduleProperties",
")",
"{",
"String",
"importModuleName",
"=",
"moduleProperties",
".",
"getProperty",
"(",
"ImportDataProcessor",
".",
"IMPORT_MODULE",
")",
";",
"String",
"attrs",
"[",
"]",
"=",
"imp... | Checks if the module for importer has been loaded in the memory. If bundle doesn't exists, it loades one and
updates the mapping records of the bundles.
@param moduleProperties
@return true, if the bundle corresponding to the importer is in memory (uploaded or was already present) | [
"Checks",
"if",
"the",
"module",
"for",
"importer",
"has",
"been",
"loaded",
"in",
"the",
"memory",
".",
"If",
"bundle",
"doesn",
"t",
"exists",
"it",
"loades",
"one",
"and",
"updates",
"the",
"mapping",
"records",
"of",
"the",
"bundles",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/importer/ImportManager.java#L225-L264 | train |
VoltDB/voltdb | src/frontend/org/voltdb/NonVoltDBBackend.java | NonVoltDBBackend.printCaughtException | protected static void printCaughtException(String exceptionMessage) {
if (++countCaughtExceptions <= MAX_CAUGHT_EXCEPTION_MESSAGES) {
System.out.println(exceptionMessage);
}
if (countCaughtExceptions == MAX_CAUGHT_EXCEPTION_MESSAGES) {
System.out.println("In NonVoltDBBackend, reached limit of " + MAX_CAUGHT_EXCEPTION_MESSAGES
+ " exception messages to be printed.");
}
} | java | protected static void printCaughtException(String exceptionMessage) {
if (++countCaughtExceptions <= MAX_CAUGHT_EXCEPTION_MESSAGES) {
System.out.println(exceptionMessage);
}
if (countCaughtExceptions == MAX_CAUGHT_EXCEPTION_MESSAGES) {
System.out.println("In NonVoltDBBackend, reached limit of " + MAX_CAUGHT_EXCEPTION_MESSAGES
+ " exception messages to be printed.");
}
} | [
"protected",
"static",
"void",
"printCaughtException",
"(",
"String",
"exceptionMessage",
")",
"{",
"if",
"(",
"++",
"countCaughtExceptions",
"<=",
"MAX_CAUGHT_EXCEPTION_MESSAGES",
")",
"{",
"System",
".",
"out",
".",
"println",
"(",
"exceptionMessage",
")",
";",
... | Print a message about an Exception that was caught; but limit the number
of such print messages, so that the console is not swamped by them. | [
"Print",
"a",
"message",
"about",
"an",
"Exception",
"that",
"was",
"caught",
";",
"but",
"limit",
"the",
"number",
"of",
"such",
"print",
"messages",
"so",
"that",
"the",
"console",
"is",
"not",
"swamped",
"by",
"them",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/NonVoltDBBackend.java#L418-L426 | train |
VoltDB/voltdb | src/frontend/org/voltdb/NonVoltDBBackend.java | NonVoltDBBackend.getAllColumns | protected List<String> getAllColumns(String tableName) {
List<String> columns = new ArrayList<String>();
try {
// Lower-case table names are required for PostgreSQL; we might need to
// alter this if we use another comparison database (besides HSQL) someday
ResultSet rs = dbconn.getMetaData().getColumns(null, null, tableName.toLowerCase(), null);
while (rs.next()) {
columns.add(rs.getString(4));
}
} catch (SQLException e) {
printCaughtException("In NonVoltDBBackend.getAllColumns, caught SQLException: " + e);
}
return columns;
} | java | protected List<String> getAllColumns(String tableName) {
List<String> columns = new ArrayList<String>();
try {
// Lower-case table names are required for PostgreSQL; we might need to
// alter this if we use another comparison database (besides HSQL) someday
ResultSet rs = dbconn.getMetaData().getColumns(null, null, tableName.toLowerCase(), null);
while (rs.next()) {
columns.add(rs.getString(4));
}
} catch (SQLException e) {
printCaughtException("In NonVoltDBBackend.getAllColumns, caught SQLException: " + e);
}
return columns;
} | [
"protected",
"List",
"<",
"String",
">",
"getAllColumns",
"(",
"String",
"tableName",
")",
"{",
"List",
"<",
"String",
">",
"columns",
"=",
"new",
"ArrayList",
"<",
"String",
">",
"(",
")",
";",
"try",
"{",
"// Lower-case table names are required for PostgreSQL;... | Returns all column names for the specified table, in the order defined
in the DDL. | [
"Returns",
"all",
"column",
"names",
"for",
"the",
"specified",
"table",
"in",
"the",
"order",
"defined",
"in",
"the",
"DDL",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/NonVoltDBBackend.java#L430-L443 | train |
VoltDB/voltdb | src/frontend/org/voltdb/NonVoltDBBackend.java | NonVoltDBBackend.getPrimaryKeys | protected List<String> getPrimaryKeys(String tableName) {
List<String> pkCols = new ArrayList<String>();
try {
// Lower-case table names are required for PostgreSQL; we might need to
// alter this if we use another comparison database (besides HSQL) someday
ResultSet rs = dbconn.getMetaData().getPrimaryKeys(null, null, tableName.toLowerCase());
while (rs.next()) {
pkCols.add(rs.getString(4));
}
} catch (SQLException e) {
printCaughtException("In NonVoltDBBackend.getPrimaryKeys, caught SQLException: " + e);
}
return pkCols;
} | java | protected List<String> getPrimaryKeys(String tableName) {
List<String> pkCols = new ArrayList<String>();
try {
// Lower-case table names are required for PostgreSQL; we might need to
// alter this if we use another comparison database (besides HSQL) someday
ResultSet rs = dbconn.getMetaData().getPrimaryKeys(null, null, tableName.toLowerCase());
while (rs.next()) {
pkCols.add(rs.getString(4));
}
} catch (SQLException e) {
printCaughtException("In NonVoltDBBackend.getPrimaryKeys, caught SQLException: " + e);
}
return pkCols;
} | [
"protected",
"List",
"<",
"String",
">",
"getPrimaryKeys",
"(",
"String",
"tableName",
")",
"{",
"List",
"<",
"String",
">",
"pkCols",
"=",
"new",
"ArrayList",
"<",
"String",
">",
"(",
")",
";",
"try",
"{",
"// Lower-case table names are required for PostgreSQL;... | Returns all primary key column names for the specified table, in the
order defined in the DDL. | [
"Returns",
"all",
"primary",
"key",
"column",
"names",
"for",
"the",
"specified",
"table",
"in",
"the",
"order",
"defined",
"in",
"the",
"DDL",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/NonVoltDBBackend.java#L447-L460 | train |
VoltDB/voltdb | src/frontend/org/voltdb/NonVoltDBBackend.java | NonVoltDBBackend.getNonPrimaryKeyColumns | protected List<String> getNonPrimaryKeyColumns(String tableName) {
List<String> columns = getAllColumns(tableName);
columns.removeAll(getPrimaryKeys(tableName));
return columns;
} | java | protected List<String> getNonPrimaryKeyColumns(String tableName) {
List<String> columns = getAllColumns(tableName);
columns.removeAll(getPrimaryKeys(tableName));
return columns;
} | [
"protected",
"List",
"<",
"String",
">",
"getNonPrimaryKeyColumns",
"(",
"String",
"tableName",
")",
"{",
"List",
"<",
"String",
">",
"columns",
"=",
"getAllColumns",
"(",
"tableName",
")",
";",
"columns",
".",
"removeAll",
"(",
"getPrimaryKeys",
"(",
"tableNa... | Returns all non-primary-key column names for the specified table, in the
order defined in the DDL. | [
"Returns",
"all",
"non",
"-",
"primary",
"-",
"key",
"column",
"names",
"for",
"the",
"specified",
"table",
"in",
"the",
"order",
"defined",
"in",
"the",
"DDL",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/NonVoltDBBackend.java#L464-L468 | train |
VoltDB/voltdb | src/frontend/org/voltdb/NonVoltDBBackend.java | NonVoltDBBackend.transformQuery | protected String transformQuery(String query, QueryTransformer ... qts) {
String result = query;
for (QueryTransformer qt : qts) {
result = transformQuery(result, qt);
}
return result;
} | java | protected String transformQuery(String query, QueryTransformer ... qts) {
String result = query;
for (QueryTransformer qt : qts) {
result = transformQuery(result, qt);
}
return result;
} | [
"protected",
"String",
"transformQuery",
"(",
"String",
"query",
",",
"QueryTransformer",
"...",
"qts",
")",
"{",
"String",
"result",
"=",
"query",
";",
"for",
"(",
"QueryTransformer",
"qt",
":",
"qts",
")",
"{",
"result",
"=",
"transformQuery",
"(",
"result... | Calls the transformQuery method above multiple times, for each
specified QueryTransformer. | [
"Calls",
"the",
"transformQuery",
"method",
"above",
"multiple",
"times",
"for",
"each",
"specified",
"QueryTransformer",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/NonVoltDBBackend.java#L899-L905 | train |
VoltDB/voltdb | src/frontend/org/voltdb/NonVoltDBBackend.java | NonVoltDBBackend.printTransformedSql | static protected void printTransformedSql(String originalSql, String modifiedSql) {
if (transformedSqlFileWriter != null && !originalSql.equals(modifiedSql)) {
try {
transformedSqlFileWriter.write("original SQL: " + originalSql + "\n");
transformedSqlFileWriter.write("modified SQL: " + modifiedSql + "\n");
} catch (IOException e) {
printCaughtException("Caught IOException:\n " + e
+ "\noriginal SQL: " + originalSql
+ "\nmodified SQL: " + modifiedSql);
}
}
} | java | static protected void printTransformedSql(String originalSql, String modifiedSql) {
if (transformedSqlFileWriter != null && !originalSql.equals(modifiedSql)) {
try {
transformedSqlFileWriter.write("original SQL: " + originalSql + "\n");
transformedSqlFileWriter.write("modified SQL: " + modifiedSql + "\n");
} catch (IOException e) {
printCaughtException("Caught IOException:\n " + e
+ "\noriginal SQL: " + originalSql
+ "\nmodified SQL: " + modifiedSql);
}
}
} | [
"static",
"protected",
"void",
"printTransformedSql",
"(",
"String",
"originalSql",
",",
"String",
"modifiedSql",
")",
"{",
"if",
"(",
"transformedSqlFileWriter",
"!=",
"null",
"&&",
"!",
"originalSql",
".",
"equals",
"(",
"modifiedSql",
")",
")",
"{",
"try",
... | Prints the original and modified SQL statements, to the "Transformed
SQL" output file, assuming that that file is defined; and only if
the original and modified SQL are not the same, i.e., only if some
transformation has indeed taken place. | [
"Prints",
"the",
"original",
"and",
"modified",
"SQL",
"statements",
"to",
"the",
"Transformed",
"SQL",
"output",
"file",
"assuming",
"that",
"that",
"file",
"is",
"defined",
";",
"and",
"only",
"if",
"the",
"original",
"and",
"modified",
"SQL",
"are",
"not"... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/NonVoltDBBackend.java#L911-L922 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLPatternFactory.java | SQLPatternFactory.makeGroup | private static SQLPatternPart makeGroup(boolean capture, String captureLabel, SQLPatternPart part)
{
// Need an outer part if capturing something that's already a group (capturing or not)
boolean alreadyGroup = (part.m_flags & (SQLPatternFactory.GROUP | SQLPatternFactory.CAPTURE)) != 0;
SQLPatternPart retPart = alreadyGroup ? new SQLPatternPartElement(part) : part;
if (capture) {
retPart.m_flags |= SQLPatternFactory.CAPTURE;
retPart.setCaptureLabel(captureLabel);
}
else {
retPart.m_flags |= SQLPatternFactory.GROUP;
}
return retPart;
} | java | private static SQLPatternPart makeGroup(boolean capture, String captureLabel, SQLPatternPart part)
{
// Need an outer part if capturing something that's already a group (capturing or not)
boolean alreadyGroup = (part.m_flags & (SQLPatternFactory.GROUP | SQLPatternFactory.CAPTURE)) != 0;
SQLPatternPart retPart = alreadyGroup ? new SQLPatternPartElement(part) : part;
if (capture) {
retPart.m_flags |= SQLPatternFactory.CAPTURE;
retPart.setCaptureLabel(captureLabel);
}
else {
retPart.m_flags |= SQLPatternFactory.GROUP;
}
return retPart;
} | [
"private",
"static",
"SQLPatternPart",
"makeGroup",
"(",
"boolean",
"capture",
",",
"String",
"captureLabel",
",",
"SQLPatternPart",
"part",
")",
"{",
"// Need an outer part if capturing something that's already a group (capturing or not)",
"boolean",
"alreadyGroup",
"=",
"(",
... | Make a capturing or non-capturing group | [
"Make",
"a",
"capturing",
"or",
"non",
"-",
"capturing",
"group"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLPatternFactory.java#L298-L311 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/HSQLInterface.java | HSQLInterface.loadHsqldb | public static HSQLInterface loadHsqldb(ParameterStateManager psMgr) {
// Specifically set the timezone to UTC to avoid the default usage local timezone in HSQL.
// This ensures that all VoltDB data paths use the same timezone for representing time.
TimeZone.setDefault(TimeZone.getTimeZone("GMT+0"));
String name = "hsqldbinstance-" + String.valueOf(instanceId) + "-" + String.valueOf(System.currentTimeMillis());
instanceId++;
HsqlProperties props = new HsqlProperties();
try {
Session sessionProxy = DatabaseManager.newSession(DatabaseURL.S_MEM, name, "SA", "", props, 0);
// make HSQL case insensitive
sessionProxy.executeDirectStatement("SET IGNORECASE TRUE;");
sessionProxy.setParameterStateManager(psMgr);
return new HSQLInterface(sessionProxy);
}
catch (HsqlException caught) {
m_logger.warn("Unexpected error initializing the SQL parser",
caught);
caught.printStackTrace();
throw caught;
}
} | java | public static HSQLInterface loadHsqldb(ParameterStateManager psMgr) {
// Specifically set the timezone to UTC to avoid the default usage local timezone in HSQL.
// This ensures that all VoltDB data paths use the same timezone for representing time.
TimeZone.setDefault(TimeZone.getTimeZone("GMT+0"));
String name = "hsqldbinstance-" + String.valueOf(instanceId) + "-" + String.valueOf(System.currentTimeMillis());
instanceId++;
HsqlProperties props = new HsqlProperties();
try {
Session sessionProxy = DatabaseManager.newSession(DatabaseURL.S_MEM, name, "SA", "", props, 0);
// make HSQL case insensitive
sessionProxy.executeDirectStatement("SET IGNORECASE TRUE;");
sessionProxy.setParameterStateManager(psMgr);
return new HSQLInterface(sessionProxy);
}
catch (HsqlException caught) {
m_logger.warn("Unexpected error initializing the SQL parser",
caught);
caught.printStackTrace();
throw caught;
}
} | [
"public",
"static",
"HSQLInterface",
"loadHsqldb",
"(",
"ParameterStateManager",
"psMgr",
")",
"{",
"// Specifically set the timezone to UTC to avoid the default usage local timezone in HSQL.",
"// This ensures that all VoltDB data paths use the same timezone for representing time.",
"TimeZone... | Load up an HSQLDB in-memory instance.
@return A newly initialized in-memory HSQLDB instance accessible
through the returned instance of HSQLInterface | [
"Load",
"up",
"an",
"HSQLDB",
"in",
"-",
"memory",
"instance",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/HSQLInterface.java#L146-L168 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/HSQLInterface.java | HSQLInterface.runDDLCommandAndDiff | public VoltXMLDiff runDDLCommandAndDiff(HSQLDDLInfo stmtInfo,
String ddl)
throws HSQLParseException
{
// name of the table we're going to have to diff (if any)
String expectedTableAffected = null;
// If we fail to pre-process a statement, then we want to fail, but we're
// still going to run the statement through HSQL to get its error message.
// This variable helps us make sure we don't fail to preprocess and then
// succeed at runnign the statement through HSQL.
boolean expectFailure = false;
// If cascade, we're going to need to look for any views that might have
// gotten deleted. So get a list of all tables and views that existed before
// we run the ddl, then we'll do a comparison later.
Set<String> existingTableNames = null;
if (stmtInfo != null) {
if (stmtInfo.cascade) {
existingTableNames = getTableNames();
}
// we either have an index name or a table/view name, but not both
if (stmtInfo.noun == HSQLDDLInfo.Noun.INDEX) {
if (stmtInfo.verb == HSQLDDLInfo.Verb.CREATE) {
expectedTableAffected = stmtInfo.secondName;
}
else {
expectedTableAffected = tableNameForIndexName(stmtInfo.name);
}
}
else {
expectedTableAffected = stmtInfo.name;
}
// Note that we're assuming ifexists can't happen with "create"
expectFailure = (expectedTableAffected == null) && !stmtInfo.ifexists;
}
else {
expectFailure = true;
}
runDDLCommand(ddl);
// If we expect to fail, but the statement above didn't bail...
// (Shouldn't get here ever I think)
if (expectFailure) {
throw new HSQLParseException("Unable to plan statement due to VoltDB DDL pre-processing error");
}
// sanity checks for non-failure
assert(stmtInfo != null);
// get old and new XML representations for the affected table
VoltXMLElement tableXMLNew = null, tableXMLOld = null;
if (expectedTableAffected != null) {
tableXMLNew = getXMLForTable(expectedTableAffected);
tableXMLOld = lastSchema.get(expectedTableAffected);
}
// valid reasons for tableXMLNew to be null are DROP IF EXISTS and not much else
if (tableXMLNew == null) {
tableXMLNew = emptySchema;
}
// the old table can be null for CREATE TABLE or for IF EXISTS stuff
if (tableXMLOld == null) {
tableXMLOld = emptySchema;
}
VoltXMLDiff diff = VoltXMLElement.computeDiff(tableXMLOld, tableXMLNew);
// now find any views that might be missing and make sure the diff reflects that
// they're gone
if (stmtInfo.cascade) {
Set<String> finalTableNames = getTableNames();
for (String tableName : existingTableNames) {
if (!finalTableNames.contains(tableName)) {
tableName = tableName.toLowerCase();
tableXMLOld = lastSchema.get(tableName).children.get(0);
lastSchema.remove(tableName);
if (tableName.equals(expectedTableAffected)) {
continue;
}
diff.m_removedElements.add(tableXMLOld);
}
}
}
// this is a hack to allow the diff-apply-er to accept a diff that has no order
diff.m_elementOrder.clear();
// remember the current schema
if (expectedTableAffected != null) {
lastSchema.put(expectedTableAffected, tableXMLNew.duplicate());
}
return diff;
} | java | public VoltXMLDiff runDDLCommandAndDiff(HSQLDDLInfo stmtInfo,
String ddl)
throws HSQLParseException
{
// name of the table we're going to have to diff (if any)
String expectedTableAffected = null;
// If we fail to pre-process a statement, then we want to fail, but we're
// still going to run the statement through HSQL to get its error message.
// This variable helps us make sure we don't fail to preprocess and then
// succeed at runnign the statement through HSQL.
boolean expectFailure = false;
// If cascade, we're going to need to look for any views that might have
// gotten deleted. So get a list of all tables and views that existed before
// we run the ddl, then we'll do a comparison later.
Set<String> existingTableNames = null;
if (stmtInfo != null) {
if (stmtInfo.cascade) {
existingTableNames = getTableNames();
}
// we either have an index name or a table/view name, but not both
if (stmtInfo.noun == HSQLDDLInfo.Noun.INDEX) {
if (stmtInfo.verb == HSQLDDLInfo.Verb.CREATE) {
expectedTableAffected = stmtInfo.secondName;
}
else {
expectedTableAffected = tableNameForIndexName(stmtInfo.name);
}
}
else {
expectedTableAffected = stmtInfo.name;
}
// Note that we're assuming ifexists can't happen with "create"
expectFailure = (expectedTableAffected == null) && !stmtInfo.ifexists;
}
else {
expectFailure = true;
}
runDDLCommand(ddl);
// If we expect to fail, but the statement above didn't bail...
// (Shouldn't get here ever I think)
if (expectFailure) {
throw new HSQLParseException("Unable to plan statement due to VoltDB DDL pre-processing error");
}
// sanity checks for non-failure
assert(stmtInfo != null);
// get old and new XML representations for the affected table
VoltXMLElement tableXMLNew = null, tableXMLOld = null;
if (expectedTableAffected != null) {
tableXMLNew = getXMLForTable(expectedTableAffected);
tableXMLOld = lastSchema.get(expectedTableAffected);
}
// valid reasons for tableXMLNew to be null are DROP IF EXISTS and not much else
if (tableXMLNew == null) {
tableXMLNew = emptySchema;
}
// the old table can be null for CREATE TABLE or for IF EXISTS stuff
if (tableXMLOld == null) {
tableXMLOld = emptySchema;
}
VoltXMLDiff diff = VoltXMLElement.computeDiff(tableXMLOld, tableXMLNew);
// now find any views that might be missing and make sure the diff reflects that
// they're gone
if (stmtInfo.cascade) {
Set<String> finalTableNames = getTableNames();
for (String tableName : existingTableNames) {
if (!finalTableNames.contains(tableName)) {
tableName = tableName.toLowerCase();
tableXMLOld = lastSchema.get(tableName).children.get(0);
lastSchema.remove(tableName);
if (tableName.equals(expectedTableAffected)) {
continue;
}
diff.m_removedElements.add(tableXMLOld);
}
}
}
// this is a hack to allow the diff-apply-er to accept a diff that has no order
diff.m_elementOrder.clear();
// remember the current schema
if (expectedTableAffected != null) {
lastSchema.put(expectedTableAffected, tableXMLNew.duplicate());
}
return diff;
} | [
"public",
"VoltXMLDiff",
"runDDLCommandAndDiff",
"(",
"HSQLDDLInfo",
"stmtInfo",
",",
"String",
"ddl",
")",
"throws",
"HSQLParseException",
"{",
"// name of the table we're going to have to diff (if any)",
"String",
"expectedTableAffected",
"=",
"null",
";",
"// If we fail to p... | Modify the current schema with a SQL DDL command and get the
diff which represents the changes.
Note that you have to be consistent WRT case for the expected names.
@param expectedTableAffected The name of the table affected by this DDL
or null if unknown
@param expectedIndexAffected The name of the index affected by this DDL
or null if table is known instead
@param ddl The SQL DDL statement to be run.
@return the "diff" of the before and after trees for the affected table
@throws HSQLParseException Throws exception if SQL parse error is
encountered. | [
"Modify",
"the",
"current",
"schema",
"with",
"a",
"SQL",
"DDL",
"command",
"and",
"get",
"the",
"diff",
"which",
"represents",
"the",
"changes",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/HSQLInterface.java#L185-L282 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/HSQLInterface.java | HSQLInterface.runDDLCommand | public void runDDLCommand(String ddl) throws HSQLParseException {
sessionProxy.clearLocalTables();
Result result = sessionProxy.executeDirectStatement(ddl);
if (result.hasError()) {
throw new HSQLParseException(result.getMainString());
}
} | java | public void runDDLCommand(String ddl) throws HSQLParseException {
sessionProxy.clearLocalTables();
Result result = sessionProxy.executeDirectStatement(ddl);
if (result.hasError()) {
throw new HSQLParseException(result.getMainString());
}
} | [
"public",
"void",
"runDDLCommand",
"(",
"String",
"ddl",
")",
"throws",
"HSQLParseException",
"{",
"sessionProxy",
".",
"clearLocalTables",
"(",
")",
";",
"Result",
"result",
"=",
"sessionProxy",
".",
"executeDirectStatement",
"(",
"ddl",
")",
";",
"if",
"(",
... | Modify the current schema with a SQL DDL command.
@param ddl The SQL DDL statement to be run.
@throws HSQLParseException Throws exception if SQL parse error is
encountered. | [
"Modify",
"the",
"current",
"schema",
"with",
"a",
"SQL",
"DDL",
"command",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/HSQLInterface.java#L291-L297 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/HSQLInterface.java | HSQLInterface.fixupInStatementExpressions | private void fixupInStatementExpressions(VoltXMLElement expr) throws HSQLParseException {
if (doesExpressionReallyMeanIn(expr)) {
inFixup(expr);
// can't return because in with subquery can be nested
}
// recursive hunt
for (VoltXMLElement child : expr.children) {
fixupInStatementExpressions(child);
}
} | java | private void fixupInStatementExpressions(VoltXMLElement expr) throws HSQLParseException {
if (doesExpressionReallyMeanIn(expr)) {
inFixup(expr);
// can't return because in with subquery can be nested
}
// recursive hunt
for (VoltXMLElement child : expr.children) {
fixupInStatementExpressions(child);
}
} | [
"private",
"void",
"fixupInStatementExpressions",
"(",
"VoltXMLElement",
"expr",
")",
"throws",
"HSQLParseException",
"{",
"if",
"(",
"doesExpressionReallyMeanIn",
"(",
"expr",
")",
")",
"{",
"inFixup",
"(",
"expr",
")",
";",
"// can't return because in with subquery ca... | Recursively find all in-lists, subquery, row comparisons found in the XML and munge them into the
simpler thing we want to pass to the AbstractParsedStmt.
@throws HSQLParseException | [
"Recursively",
"find",
"all",
"in",
"-",
"lists",
"subquery",
"row",
"comparisons",
"found",
"in",
"the",
"XML",
"and",
"munge",
"them",
"into",
"the",
"simpler",
"thing",
"we",
"want",
"to",
"pass",
"to",
"the",
"AbstractParsedStmt",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/HSQLInterface.java#L418-L428 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/HSQLInterface.java | HSQLInterface.inFixup | private void inFixup(VoltXMLElement inElement) {
// make this an in expression
inElement.name = "operation";
inElement.attributes.put("optype", "in");
VoltXMLElement rowElem = null;
VoltXMLElement tableElem = null;
VoltXMLElement subqueryElem = null;
VoltXMLElement valueElem = null;
for (VoltXMLElement child : inElement.children) {
if (child.name.equals("row")) {
rowElem = child;
}
else if (child.name.equals("table")) {
tableElem = child;
}
else if (child.name.equals("tablesubquery")) {
subqueryElem = child;
}
else if (child.name.equals("value")) {
valueElem = child;
}
}
VoltXMLElement inlist;
if (tableElem != null) {
// make the table expression an in-list
inlist = new VoltXMLElement("vector");
for (VoltXMLElement child : tableElem.children) {
assert(child.name.equals("row"));
assert(child.children.size() == 1);
inlist.children.addAll(child.children);
}
}
else if (subqueryElem != null) {
inlist = subqueryElem;
}
else {
assert valueElem != null;
inlist = valueElem;
}
assert(rowElem != null);
assert(inlist != null);
inElement.children.clear();
// add the row
inElement.children.add(rowElem);
// add the inlist
inElement.children.add(inlist);
} | java | private void inFixup(VoltXMLElement inElement) {
// make this an in expression
inElement.name = "operation";
inElement.attributes.put("optype", "in");
VoltXMLElement rowElem = null;
VoltXMLElement tableElem = null;
VoltXMLElement subqueryElem = null;
VoltXMLElement valueElem = null;
for (VoltXMLElement child : inElement.children) {
if (child.name.equals("row")) {
rowElem = child;
}
else if (child.name.equals("table")) {
tableElem = child;
}
else if (child.name.equals("tablesubquery")) {
subqueryElem = child;
}
else if (child.name.equals("value")) {
valueElem = child;
}
}
VoltXMLElement inlist;
if (tableElem != null) {
// make the table expression an in-list
inlist = new VoltXMLElement("vector");
for (VoltXMLElement child : tableElem.children) {
assert(child.name.equals("row"));
assert(child.children.size() == 1);
inlist.children.addAll(child.children);
}
}
else if (subqueryElem != null) {
inlist = subqueryElem;
}
else {
assert valueElem != null;
inlist = valueElem;
}
assert(rowElem != null);
assert(inlist != null);
inElement.children.clear();
// add the row
inElement.children.add(rowElem);
// add the inlist
inElement.children.add(inlist);
} | [
"private",
"void",
"inFixup",
"(",
"VoltXMLElement",
"inElement",
")",
"{",
"// make this an in expression",
"inElement",
".",
"name",
"=",
"\"operation\"",
";",
"inElement",
".",
"attributes",
".",
"put",
"(",
"\"optype\"",
",",
"\"in\"",
")",
";",
"VoltXMLElemen... | Take an equality-test expression that represents in-list
and munge it into the simpler thing we want to output
to the AbstractParsedStmt for its AbstractExpression classes. | [
"Take",
"an",
"equality",
"-",
"test",
"expression",
"that",
"represents",
"in",
"-",
"list",
"and",
"munge",
"it",
"into",
"the",
"simpler",
"thing",
"we",
"want",
"to",
"output",
"to",
"the",
"AbstractParsedStmt",
"for",
"its",
"AbstractExpression",
"classes... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/HSQLInterface.java#L478-L527 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/HSQLInterface.java | HSQLInterface.printTables | @SuppressWarnings("unused")
private void printTables() {
try {
String schemaName = sessionProxy.getSchemaName(null);
System.out.println("*** Tables For Schema: " + schemaName + " ***");
}
catch (HsqlException caught) {
caught.printStackTrace();
}
// load all the tables
HashMappedList hsqlTables = getHSQLTables();
for (int i = 0; i < hsqlTables.size(); i++) {
Table table = (Table) hsqlTables.get(i);
System.out.println(table.getName().name);
}
} | java | @SuppressWarnings("unused")
private void printTables() {
try {
String schemaName = sessionProxy.getSchemaName(null);
System.out.println("*** Tables For Schema: " + schemaName + " ***");
}
catch (HsqlException caught) {
caught.printStackTrace();
}
// load all the tables
HashMappedList hsqlTables = getHSQLTables();
for (int i = 0; i < hsqlTables.size(); i++) {
Table table = (Table) hsqlTables.get(i);
System.out.println(table.getName().name);
}
} | [
"@",
"SuppressWarnings",
"(",
"\"unused\"",
")",
"private",
"void",
"printTables",
"(",
")",
"{",
"try",
"{",
"String",
"schemaName",
"=",
"sessionProxy",
".",
"getSchemaName",
"(",
"null",
")",
";",
"System",
".",
"out",
".",
"println",
"(",
"\"*** Tables F... | Debug-only method that prints out the names of all
tables in the current schema. | [
"Debug",
"-",
"only",
"method",
"that",
"prints",
"out",
"the",
"names",
"of",
"all",
"tables",
"in",
"the",
"current",
"schema",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/HSQLInterface.java#L533-L549 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/HSQLInterface.java | HSQLInterface.getXMLForTable | public VoltXMLElement getXMLForTable(String tableName) throws HSQLParseException {
VoltXMLElement xml = emptySchema.duplicate();
// search all the tables XXX probably could do this non-linearly,
// but i don't know about case-insensitivity yet
HashMappedList hsqlTables = getHSQLTables();
for (int i = 0; i < hsqlTables.size(); i++) {
Table table = (Table) hsqlTables.get(i);
String candidateTableName = table.getName().name;
// found the table of interest
if (candidateTableName.equalsIgnoreCase(tableName)) {
VoltXMLElement vxmle = table.voltGetTableXML(sessionProxy);
assert(vxmle != null);
xml.children.add(vxmle);
return xml;
}
}
return null;
} | java | public VoltXMLElement getXMLForTable(String tableName) throws HSQLParseException {
VoltXMLElement xml = emptySchema.duplicate();
// search all the tables XXX probably could do this non-linearly,
// but i don't know about case-insensitivity yet
HashMappedList hsqlTables = getHSQLTables();
for (int i = 0; i < hsqlTables.size(); i++) {
Table table = (Table) hsqlTables.get(i);
String candidateTableName = table.getName().name;
// found the table of interest
if (candidateTableName.equalsIgnoreCase(tableName)) {
VoltXMLElement vxmle = table.voltGetTableXML(sessionProxy);
assert(vxmle != null);
xml.children.add(vxmle);
return xml;
}
}
return null;
} | [
"public",
"VoltXMLElement",
"getXMLForTable",
"(",
"String",
"tableName",
")",
"throws",
"HSQLParseException",
"{",
"VoltXMLElement",
"xml",
"=",
"emptySchema",
".",
"duplicate",
"(",
")",
";",
"// search all the tables XXX probably could do this non-linearly,",
"// but i do... | Get a serialized XML representation of a particular table. | [
"Get",
"a",
"serialized",
"XML",
"representation",
"of",
"a",
"particular",
"table",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/HSQLInterface.java#L611-L630 | train |
VoltDB/voltdb | src/frontend/org/voltdb/importclient/kafka10/KafkaConsumerRunner.java | KafkaConsumerRunner.calculateTrackers | private void calculateTrackers(Collection<TopicPartition> partitions) {
Map<TopicPartition, CommitTracker> trackers = new HashMap<>();
trackers.putAll(m_trackerMap.get());
Map<TopicPartition, AtomicLong> lastCommittedOffSets = new HashMap<>();
lastCommittedOffSets.putAll(m_lastCommittedOffSets.get());
boolean newTopicPartition = false;
for (TopicPartition partition : partitions) {
if (m_trackerMap.get().get(partition) != null) {
continue;
}
newTopicPartition = true;
long startOffset = -1L;
CommitTracker commitTracker = null;
if (m_config.getCommitPolicy() == KafkaCommitPolicy.TIME && m_config.getTriggerValue() > 0) {
commitTracker = new SimpleTracker();
} else {
commitTracker = new DurableTracker(KafkaConstants.IMPORT_GAP_LEAD, partition.topic(),
partition.partition(), m_config.getGroupId());
}
trackers.put(partition, commitTracker);
try {
OffsetAndMetadata offsetAndMetaData = m_consumer.committed(partition);
startOffset = offsetAndMetaData != null ? offsetAndMetaData.offset() : -1L;
if (startOffset > -1L) {
commitTracker.resetTo(startOffset);
}
} catch (KafkaException e) {
LOGGER.error("Failed to read committed offsets for group " + m_config.getGroupId() + partition + " " + e.getMessage());
}
lastCommittedOffSets.put(partition, new AtomicLong(startOffset));
m_pauseOffsets.put(partition, new AtomicLong(-1));
m_workTrackers.put(partition, new PendingWorkTracker());
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Starting offset for group:" + m_config.getGroupId() + ":" + startOffset + " partition:" + partition);
}
}
if (newTopicPartition) {
m_trackerMap.set(trackers);
m_lastCommittedOffSets.set(lastCommittedOffSets);
}
} | java | private void calculateTrackers(Collection<TopicPartition> partitions) {
Map<TopicPartition, CommitTracker> trackers = new HashMap<>();
trackers.putAll(m_trackerMap.get());
Map<TopicPartition, AtomicLong> lastCommittedOffSets = new HashMap<>();
lastCommittedOffSets.putAll(m_lastCommittedOffSets.get());
boolean newTopicPartition = false;
for (TopicPartition partition : partitions) {
if (m_trackerMap.get().get(partition) != null) {
continue;
}
newTopicPartition = true;
long startOffset = -1L;
CommitTracker commitTracker = null;
if (m_config.getCommitPolicy() == KafkaCommitPolicy.TIME && m_config.getTriggerValue() > 0) {
commitTracker = new SimpleTracker();
} else {
commitTracker = new DurableTracker(KafkaConstants.IMPORT_GAP_LEAD, partition.topic(),
partition.partition(), m_config.getGroupId());
}
trackers.put(partition, commitTracker);
try {
OffsetAndMetadata offsetAndMetaData = m_consumer.committed(partition);
startOffset = offsetAndMetaData != null ? offsetAndMetaData.offset() : -1L;
if (startOffset > -1L) {
commitTracker.resetTo(startOffset);
}
} catch (KafkaException e) {
LOGGER.error("Failed to read committed offsets for group " + m_config.getGroupId() + partition + " " + e.getMessage());
}
lastCommittedOffSets.put(partition, new AtomicLong(startOffset));
m_pauseOffsets.put(partition, new AtomicLong(-1));
m_workTrackers.put(partition, new PendingWorkTracker());
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Starting offset for group:" + m_config.getGroupId() + ":" + startOffset + " partition:" + partition);
}
}
if (newTopicPartition) {
m_trackerMap.set(trackers);
m_lastCommittedOffSets.set(lastCommittedOffSets);
}
} | [
"private",
"void",
"calculateTrackers",
"(",
"Collection",
"<",
"TopicPartition",
">",
"partitions",
")",
"{",
"Map",
"<",
"TopicPartition",
",",
"CommitTracker",
">",
"trackers",
"=",
"new",
"HashMap",
"<>",
"(",
")",
";",
"trackers",
".",
"putAll",
"(",
"m... | add trackers for new topic-partition in this importer | [
"add",
"trackers",
"for",
"new",
"topic",
"-",
"partition",
"in",
"this",
"importer"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/importclient/kafka10/KafkaConsumerRunner.java#L134-L177 | train |
VoltDB/voltdb | src/frontend/org/voltdb/importclient/kafka10/KafkaConsumerRunner.java | KafkaConsumerRunner.seek | private void seek(List<TopicPartition> seekList) {
for (TopicPartition tp : seekList) {
AtomicLong lastCommittedOffset = m_lastCommittedOffSets.get().get(tp);
if (lastCommittedOffset != null && lastCommittedOffset.get() > -1L) {
AtomicLong lastSeeked = m_lastSeekedOffSets.get(tp);
//eliminate duplicate seek
if (lastSeeked != null && lastSeeked.get() == lastCommittedOffset.get()) {
continue;
}
m_consumer.seek(tp, lastCommittedOffset.longValue());
m_lastSeekedOffSets.put(tp, new AtomicLong(lastCommittedOffset.get()));
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Moves offset for group " + m_config.getGroupId() + " -" + tp + " to " + lastCommittedOffset);
}
}
}
} | java | private void seek(List<TopicPartition> seekList) {
for (TopicPartition tp : seekList) {
AtomicLong lastCommittedOffset = m_lastCommittedOffSets.get().get(tp);
if (lastCommittedOffset != null && lastCommittedOffset.get() > -1L) {
AtomicLong lastSeeked = m_lastSeekedOffSets.get(tp);
//eliminate duplicate seek
if (lastSeeked != null && lastSeeked.get() == lastCommittedOffset.get()) {
continue;
}
m_consumer.seek(tp, lastCommittedOffset.longValue());
m_lastSeekedOffSets.put(tp, new AtomicLong(lastCommittedOffset.get()));
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Moves offset for group " + m_config.getGroupId() + " -" + tp + " to " + lastCommittedOffset);
}
}
}
} | [
"private",
"void",
"seek",
"(",
"List",
"<",
"TopicPartition",
">",
"seekList",
")",
"{",
"for",
"(",
"TopicPartition",
"tp",
":",
"seekList",
")",
"{",
"AtomicLong",
"lastCommittedOffset",
"=",
"m_lastCommittedOffSets",
".",
"get",
"(",
")",
".",
"get",
"("... | Move offsets to correct positions for next poll | [
"Move",
"offsets",
"to",
"correct",
"positions",
"for",
"next",
"poll"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/importclient/kafka10/KafkaConsumerRunner.java#L355-L373 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/lib/StringUtil.java | StringUtil.toZeroPaddedString | public static String toZeroPaddedString(long value, int precision,
int maxSize) {
StringBuffer sb = new StringBuffer();
if (value < 0) {
value = -value;
}
String s = Long.toString(value);
if (s.length() > precision) {
s = s.substring(precision);
}
for (int i = s.length(); i < precision; i++) {
sb.append('0');
}
sb.append(s);
if (maxSize < precision) {
sb.setLength(maxSize);
}
return sb.toString();
} | java | public static String toZeroPaddedString(long value, int precision,
int maxSize) {
StringBuffer sb = new StringBuffer();
if (value < 0) {
value = -value;
}
String s = Long.toString(value);
if (s.length() > precision) {
s = s.substring(precision);
}
for (int i = s.length(); i < precision; i++) {
sb.append('0');
}
sb.append(s);
if (maxSize < precision) {
sb.setLength(maxSize);
}
return sb.toString();
} | [
"public",
"static",
"String",
"toZeroPaddedString",
"(",
"long",
"value",
",",
"int",
"precision",
",",
"int",
"maxSize",
")",
"{",
"StringBuffer",
"sb",
"=",
"new",
"StringBuffer",
"(",
")",
";",
"if",
"(",
"value",
"<",
"0",
")",
"{",
"value",
"=",
"... | If necessary, adds zeros to the beginning of a value so that the total
length matches the given precision, otherwise trims the right digits.
Then if maxSize is smaller than precision, trims the right digits to
maxSize. Negative values are treated as positive | [
"If",
"necessary",
"adds",
"zeros",
"to",
"the",
"beginning",
"of",
"a",
"value",
"so",
"that",
"the",
"total",
"length",
"matches",
"the",
"given",
"precision",
"otherwise",
"trims",
"the",
"right",
"digits",
".",
"Then",
"if",
"maxSize",
"is",
"smaller",
... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/lib/StringUtil.java#L53-L79 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/lib/StringUtil.java | StringUtil.toLowerSubset | public static String toLowerSubset(String source, char substitute) {
int len = source.length();
StringBuffer sb = new StringBuffer(len);
char ch;
for (int i = 0; i < len; i++) {
ch = source.charAt(i);
if (!Character.isLetterOrDigit(ch)) {
sb.append(substitute);
} else if ((i == 0) && Character.isDigit(ch)) {
sb.append(substitute);
} else {
sb.append(Character.toLowerCase(ch));
}
}
return sb.toString();
} | java | public static String toLowerSubset(String source, char substitute) {
int len = source.length();
StringBuffer sb = new StringBuffer(len);
char ch;
for (int i = 0; i < len; i++) {
ch = source.charAt(i);
if (!Character.isLetterOrDigit(ch)) {
sb.append(substitute);
} else if ((i == 0) && Character.isDigit(ch)) {
sb.append(substitute);
} else {
sb.append(Character.toLowerCase(ch));
}
}
return sb.toString();
} | [
"public",
"static",
"String",
"toLowerSubset",
"(",
"String",
"source",
",",
"char",
"substitute",
")",
"{",
"int",
"len",
"=",
"source",
".",
"length",
"(",
")",
";",
"StringBuffer",
"sb",
"=",
"new",
"StringBuffer",
"(",
"len",
")",
";",
"char",
"ch",
... | Returns a string with non alphanumeric chars converted to the
substitute character. A digit first character is also converted.
By sqlbob@users
@param source string to convert
@param substitute character to use
@return converted string | [
"Returns",
"a",
"string",
"with",
"non",
"alphanumeric",
"chars",
"converted",
"to",
"the",
"substitute",
"character",
".",
"A",
"digit",
"first",
"character",
"is",
"also",
"converted",
".",
"By",
"sqlbob"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/lib/StringUtil.java#L115-L134 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/lib/StringUtil.java | StringUtil.arrayToString | public static String arrayToString(Object array) {
int len = Array.getLength(array);
int last = len - 1;
StringBuffer sb = new StringBuffer(2 * (len + 1));
sb.append('{');
for (int i = 0; i < len; i++) {
sb.append(Array.get(array, i));
if (i != last) {
sb.append(',');
}
}
sb.append('}');
return sb.toString();
} | java | public static String arrayToString(Object array) {
int len = Array.getLength(array);
int last = len - 1;
StringBuffer sb = new StringBuffer(2 * (len + 1));
sb.append('{');
for (int i = 0; i < len; i++) {
sb.append(Array.get(array, i));
if (i != last) {
sb.append(',');
}
}
sb.append('}');
return sb.toString();
} | [
"public",
"static",
"String",
"arrayToString",
"(",
"Object",
"array",
")",
"{",
"int",
"len",
"=",
"Array",
".",
"getLength",
"(",
"array",
")",
";",
"int",
"last",
"=",
"len",
"-",
"1",
";",
"StringBuffer",
"sb",
"=",
"new",
"StringBuffer",
"(",
"2",... | Builds a bracketed CSV list from the array
@param array an array of Objects
@return string | [
"Builds",
"a",
"bracketed",
"CSV",
"list",
"from",
"the",
"array"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/lib/StringUtil.java#L141-L160 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/lib/StringUtil.java | StringUtil.appendPair | public static void appendPair(StringBuffer b, String s1, String s2,
String separator, String terminator) {
b.append(s1);
b.append(separator);
b.append(s2);
b.append(terminator);
} | java | public static void appendPair(StringBuffer b, String s1, String s2,
String separator, String terminator) {
b.append(s1);
b.append(separator);
b.append(s2);
b.append(terminator);
} | [
"public",
"static",
"void",
"appendPair",
"(",
"StringBuffer",
"b",
",",
"String",
"s1",
",",
"String",
"s2",
",",
"String",
"separator",
",",
"String",
"terminator",
")",
"{",
"b",
".",
"append",
"(",
"s1",
")",
";",
"b",
".",
"append",
"(",
"separato... | Appends a pair of string to the string buffer, using the separator between
and terminator at the end
@param b the buffer
@param s1 first string
@param s2 second string
@param separator separator string
@param terminator terminator string | [
"Appends",
"a",
"pair",
"of",
"string",
"to",
"the",
"string",
"buffer",
"using",
"the",
"separator",
"between",
"and",
"terminator",
"at",
"the",
"end"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/lib/StringUtil.java#L279-L286 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/lib/StringUtil.java | StringUtil.rightTrimSize | public static int rightTrimSize(String s) {
int i = s.length();
while (i > 0) {
i--;
if (s.charAt(i) != ' ') {
return i + 1;
}
}
return 0;
} | java | public static int rightTrimSize(String s) {
int i = s.length();
while (i > 0) {
i--;
if (s.charAt(i) != ' ') {
return i + 1;
}
}
return 0;
} | [
"public",
"static",
"int",
"rightTrimSize",
"(",
"String",
"s",
")",
"{",
"int",
"i",
"=",
"s",
".",
"length",
"(",
")",
";",
"while",
"(",
"i",
">",
"0",
")",
"{",
"i",
"--",
";",
"if",
"(",
"s",
".",
"charAt",
"(",
"i",
")",
"!=",
"'",
"'... | Returns the size of substring that does not contain any trailing spaces
@param s the string
@return trimmed size | [
"Returns",
"the",
"size",
"of",
"substring",
"that",
"does",
"not",
"contain",
"any",
"trailing",
"spaces"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/lib/StringUtil.java#L312-L325 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/lib/StringUtil.java | StringUtil.skipSpaces | public static int skipSpaces(String s, int start) {
int limit = s.length();
int i = start;
for (; i < limit; i++) {
if (s.charAt(i) != ' ') {
break;
}
}
return i;
} | java | public static int skipSpaces(String s, int start) {
int limit = s.length();
int i = start;
for (; i < limit; i++) {
if (s.charAt(i) != ' ') {
break;
}
}
return i;
} | [
"public",
"static",
"int",
"skipSpaces",
"(",
"String",
"s",
",",
"int",
"start",
")",
"{",
"int",
"limit",
"=",
"s",
".",
"length",
"(",
")",
";",
"int",
"i",
"=",
"start",
";",
"for",
"(",
";",
"i",
"<",
"limit",
";",
"i",
"++",
")",
"{",
"... | Skips any spaces at or after start and returns the index of first
non-space character;
@param s the string
@param start index to start
@return index of first non-space | [
"Skips",
"any",
"spaces",
"at",
"or",
"after",
"start",
"and",
"returns",
"the",
"index",
"of",
"first",
"non",
"-",
"space",
"character",
";"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/lib/StringUtil.java#L334-L346 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/lib/StringUtil.java | StringUtil.split | public static String[] split(String s, String separator) {
HsqlArrayList list = new HsqlArrayList();
int currindex = 0;
for (boolean more = true; more; ) {
int nextindex = s.indexOf(separator, currindex);
if (nextindex == -1) {
nextindex = s.length();
more = false;
}
list.add(s.substring(currindex, nextindex));
currindex = nextindex + separator.length();
}
return (String[]) list.toArray(new String[list.size()]);
} | java | public static String[] split(String s, String separator) {
HsqlArrayList list = new HsqlArrayList();
int currindex = 0;
for (boolean more = true; more; ) {
int nextindex = s.indexOf(separator, currindex);
if (nextindex == -1) {
nextindex = s.length();
more = false;
}
list.add(s.substring(currindex, nextindex));
currindex = nextindex + separator.length();
}
return (String[]) list.toArray(new String[list.size()]);
} | [
"public",
"static",
"String",
"[",
"]",
"split",
"(",
"String",
"s",
",",
"String",
"separator",
")",
"{",
"HsqlArrayList",
"list",
"=",
"new",
"HsqlArrayList",
"(",
")",
";",
"int",
"currindex",
"=",
"0",
";",
"for",
"(",
"boolean",
"more",
"=",
"true... | Splits the string into an array, using the separator. If separator is
not found in the string, the whole string is returned in the array.
@param s the string
@param separator the separator
@return array of strings | [
"Splits",
"the",
"string",
"into",
"an",
"array",
"using",
"the",
"separator",
".",
"If",
"separator",
"is",
"not",
"found",
"in",
"the",
"string",
"the",
"whole",
"string",
"is",
"returned",
"in",
"the",
"array",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/lib/StringUtil.java#L356-L375 | train |
VoltDB/voltdb | src/frontend/org/voltdb/ExportStatsBase.java | ExportStatsBase.populateColumnSchema | @Override
protected void populateColumnSchema(ArrayList<ColumnInfo> columns) {
super.populateColumnSchema(columns);
columns.add(new ColumnInfo(VoltSystemProcedure.CNAME_SITE_ID, VoltSystemProcedure.CTYPE_ID));
columns.add(new ColumnInfo(Columns.PARTITION_ID, VoltType.BIGINT));
columns.add(new ColumnInfo(Columns.SOURCE_NAME, VoltType.STRING));
columns.add(new ColumnInfo(Columns.EXPORT_TARGET, VoltType.STRING));
columns.add(new ColumnInfo(Columns.ACTIVE, VoltType.STRING));
columns.add(new ColumnInfo(Columns.TUPLE_COUNT, VoltType.BIGINT));
columns.add(new ColumnInfo(Columns.TUPLE_PENDING, VoltType.BIGINT));
columns.add(new ColumnInfo(Columns.LAST_QUEUED_TIMESTAMP, VoltType.TIMESTAMP));
columns.add(new ColumnInfo(Columns.LAST_ACKED_TIMESTAMP, VoltType.TIMESTAMP));
columns.add(new ColumnInfo(Columns.AVERAGE_LATENCY, VoltType.BIGINT));
columns.add(new ColumnInfo(Columns.MAX_LATENCY, VoltType.BIGINT));
columns.add(new ColumnInfo(Columns.QUEUE_GAP, VoltType.BIGINT));
columns.add(new ColumnInfo(Columns.STATUS, VoltType.STRING));
} | java | @Override
protected void populateColumnSchema(ArrayList<ColumnInfo> columns) {
super.populateColumnSchema(columns);
columns.add(new ColumnInfo(VoltSystemProcedure.CNAME_SITE_ID, VoltSystemProcedure.CTYPE_ID));
columns.add(new ColumnInfo(Columns.PARTITION_ID, VoltType.BIGINT));
columns.add(new ColumnInfo(Columns.SOURCE_NAME, VoltType.STRING));
columns.add(new ColumnInfo(Columns.EXPORT_TARGET, VoltType.STRING));
columns.add(new ColumnInfo(Columns.ACTIVE, VoltType.STRING));
columns.add(new ColumnInfo(Columns.TUPLE_COUNT, VoltType.BIGINT));
columns.add(new ColumnInfo(Columns.TUPLE_PENDING, VoltType.BIGINT));
columns.add(new ColumnInfo(Columns.LAST_QUEUED_TIMESTAMP, VoltType.TIMESTAMP));
columns.add(new ColumnInfo(Columns.LAST_ACKED_TIMESTAMP, VoltType.TIMESTAMP));
columns.add(new ColumnInfo(Columns.AVERAGE_LATENCY, VoltType.BIGINT));
columns.add(new ColumnInfo(Columns.MAX_LATENCY, VoltType.BIGINT));
columns.add(new ColumnInfo(Columns.QUEUE_GAP, VoltType.BIGINT));
columns.add(new ColumnInfo(Columns.STATUS, VoltType.STRING));
} | [
"@",
"Override",
"protected",
"void",
"populateColumnSchema",
"(",
"ArrayList",
"<",
"ColumnInfo",
">",
"columns",
")",
"{",
"super",
".",
"populateColumnSchema",
"(",
"columns",
")",
";",
"columns",
".",
"add",
"(",
"new",
"ColumnInfo",
"(",
"VoltSystemProcedur... | Check cluster.py and checkstats.py if order of the columns is changed, | [
"Check",
"cluster",
".",
"py",
"and",
"checkstats",
".",
"py",
"if",
"order",
"of",
"the",
"columns",
"is",
"changed"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/ExportStatsBase.java#L90-L106 | train |
VoltDB/voltdb | src/frontend/org/voltdb/iv2/BufferedReadLog.java | BufferedReadLog.offerInternal | private void offerInternal(Mailbox mailbox, Item item, long handle) {
m_bufferedReads.add(item);
releaseBufferedReads(mailbox, handle);
} | java | private void offerInternal(Mailbox mailbox, Item item, long handle) {
m_bufferedReads.add(item);
releaseBufferedReads(mailbox, handle);
} | [
"private",
"void",
"offerInternal",
"(",
"Mailbox",
"mailbox",
",",
"Item",
"item",
",",
"long",
"handle",
")",
"{",
"m_bufferedReads",
".",
"add",
"(",
"item",
")",
";",
"releaseBufferedReads",
"(",
"mailbox",
",",
"handle",
")",
";",
"}"
] | SPI offers a new message. | [
"SPI",
"offers",
"a",
"new",
"message",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/iv2/BufferedReadLog.java#L98-L101 | train |
VoltDB/voltdb | src/frontend/org/voltdb/export/StreamBlockQueue.java | StreamBlockQueue.sizeInBytes | public long sizeInBytes() throws IOException {
long memoryBlockUsage = 0;
for (StreamBlock b : m_memoryDeque) {
//Use only total size, but throw in the USO
//to make book keeping consistent when flushed to disk
//Also dont count persisted blocks.
memoryBlockUsage += b.totalSize();
}
//Subtract USO from on disk size
return memoryBlockUsage + m_reader.sizeInBytes() - (StreamBlock.HEADER_SIZE * m_reader.getNumObjects());
} | java | public long sizeInBytes() throws IOException {
long memoryBlockUsage = 0;
for (StreamBlock b : m_memoryDeque) {
//Use only total size, but throw in the USO
//to make book keeping consistent when flushed to disk
//Also dont count persisted blocks.
memoryBlockUsage += b.totalSize();
}
//Subtract USO from on disk size
return memoryBlockUsage + m_reader.sizeInBytes() - (StreamBlock.HEADER_SIZE * m_reader.getNumObjects());
} | [
"public",
"long",
"sizeInBytes",
"(",
")",
"throws",
"IOException",
"{",
"long",
"memoryBlockUsage",
"=",
"0",
";",
"for",
"(",
"StreamBlock",
"b",
":",
"m_memoryDeque",
")",
"{",
"//Use only total size, but throw in the USO",
"//to make book keeping consistent when flush... | Only used in tests, should be removed. | [
"Only",
"used",
"in",
"tests",
"should",
"be",
"removed",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/export/StreamBlockQueue.java#L308-L318 | train |
VoltDB/voltdb | src/frontend/org/voltdb/export/StreamBlockQueue.java | StreamBlockQueue.truncateToSequenceNumber | public void truncateToSequenceNumber(final long truncationSeqNo) throws IOException {
assert(m_memoryDeque.isEmpty());
m_persistentDeque.parseAndTruncate(new BinaryDequeTruncator() {
@Override
public TruncatorResponse parse(BBContainer bbc) {
ByteBuffer b = bbc.b();
ByteOrder endianness = b.order();
b.order(ByteOrder.LITTLE_ENDIAN);
try {
final long startSequenceNumber = b.getLong();
// If after the truncation point is the first row in the block, the entire block is to be discarded
if (startSequenceNumber > truncationSeqNo) {
return PersistentBinaryDeque.fullTruncateResponse();
}
final long committedSequenceNumber = b.getLong(); // committedSequenceNumber
final int tupleCountPos = b.position();
final int tupleCount = b.getInt();
// There is nothing to do with this buffer
final long lastSequenceNumber = startSequenceNumber + tupleCount - 1;
if (lastSequenceNumber <= truncationSeqNo) {
return null;
}
b.getLong(); // uniqueId
// Partial truncation
int offset = 0;
while (b.hasRemaining()) {
if (startSequenceNumber + offset > truncationSeqNo) {
// The sequence number of this row is the greater than the truncation sequence number.
// Don't want this row, but want to preserve all rows before it.
// Move back before the row length prefix, txnId and header
// Return everything in the block before the truncation point.
// Indicate this is the end of the interesting data.
b.limit(b.position());
// update tuple count in the header
b.putInt(tupleCountPos, offset - 1);
b.position(0);
return new ByteBufferTruncatorResponse(b);
}
offset++;
// Not the row we are looking to truncate at. Skip past it (row length + row length field).
final int rowLength = b.getInt();
b.position(b.position() + rowLength);
}
return null;
} finally {
b.order(endianness);
}
}
});
// close reopen reader
m_persistentDeque.close();
CatalogContext catalogContext = VoltDB.instance().getCatalogContext();
Table streamTable = VoltDB.instance().getCatalogContext().database.getTables().get(m_streamName);
StreamTableSchemaSerializer ds = new StreamTableSchemaSerializer(
streamTable, m_streamName, catalogContext.m_genId);
m_persistentDeque = new PersistentBinaryDeque(m_nonce, ds, new VoltFile(m_path), exportLog,
!DISABLE_COMPRESSION);
m_reader = m_persistentDeque.openForRead(m_nonce);
// temporary debug stmt
exportLog.info("After truncate, PBD size is " + (m_reader.sizeInBytes() - (8 * m_reader.getNumObjects())));
} | java | public void truncateToSequenceNumber(final long truncationSeqNo) throws IOException {
assert(m_memoryDeque.isEmpty());
m_persistentDeque.parseAndTruncate(new BinaryDequeTruncator() {
@Override
public TruncatorResponse parse(BBContainer bbc) {
ByteBuffer b = bbc.b();
ByteOrder endianness = b.order();
b.order(ByteOrder.LITTLE_ENDIAN);
try {
final long startSequenceNumber = b.getLong();
// If after the truncation point is the first row in the block, the entire block is to be discarded
if (startSequenceNumber > truncationSeqNo) {
return PersistentBinaryDeque.fullTruncateResponse();
}
final long committedSequenceNumber = b.getLong(); // committedSequenceNumber
final int tupleCountPos = b.position();
final int tupleCount = b.getInt();
// There is nothing to do with this buffer
final long lastSequenceNumber = startSequenceNumber + tupleCount - 1;
if (lastSequenceNumber <= truncationSeqNo) {
return null;
}
b.getLong(); // uniqueId
// Partial truncation
int offset = 0;
while (b.hasRemaining()) {
if (startSequenceNumber + offset > truncationSeqNo) {
// The sequence number of this row is the greater than the truncation sequence number.
// Don't want this row, but want to preserve all rows before it.
// Move back before the row length prefix, txnId and header
// Return everything in the block before the truncation point.
// Indicate this is the end of the interesting data.
b.limit(b.position());
// update tuple count in the header
b.putInt(tupleCountPos, offset - 1);
b.position(0);
return new ByteBufferTruncatorResponse(b);
}
offset++;
// Not the row we are looking to truncate at. Skip past it (row length + row length field).
final int rowLength = b.getInt();
b.position(b.position() + rowLength);
}
return null;
} finally {
b.order(endianness);
}
}
});
// close reopen reader
m_persistentDeque.close();
CatalogContext catalogContext = VoltDB.instance().getCatalogContext();
Table streamTable = VoltDB.instance().getCatalogContext().database.getTables().get(m_streamName);
StreamTableSchemaSerializer ds = new StreamTableSchemaSerializer(
streamTable, m_streamName, catalogContext.m_genId);
m_persistentDeque = new PersistentBinaryDeque(m_nonce, ds, new VoltFile(m_path), exportLog,
!DISABLE_COMPRESSION);
m_reader = m_persistentDeque.openForRead(m_nonce);
// temporary debug stmt
exportLog.info("After truncate, PBD size is " + (m_reader.sizeInBytes() - (8 * m_reader.getNumObjects())));
} | [
"public",
"void",
"truncateToSequenceNumber",
"(",
"final",
"long",
"truncationSeqNo",
")",
"throws",
"IOException",
"{",
"assert",
"(",
"m_memoryDeque",
".",
"isEmpty",
"(",
")",
")",
";",
"m_persistentDeque",
".",
"parseAndTruncate",
"(",
"new",
"BinaryDequeTrunca... | See PDB segment layout at beginning of this file. | [
"See",
"PDB",
"segment",
"layout",
"at",
"beginning",
"of",
"this",
"file",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/export/StreamBlockQueue.java#L337-L400 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/store/BitMap.java | BitMap.set | public int set(int pos) {
while (pos >= capacity) {
doubleCapacity();
}
if (pos >= limitPos) {
limitPos = pos + 1;
}
int windex = pos >> 5;
int mask = 0x80000000 >>> (pos & 0x1F);
int word = map[windex];
int result = (word & mask) == 0 ? 0
: 1;
map[windex] = (word | mask);
return result;
} | java | public int set(int pos) {
while (pos >= capacity) {
doubleCapacity();
}
if (pos >= limitPos) {
limitPos = pos + 1;
}
int windex = pos >> 5;
int mask = 0x80000000 >>> (pos & 0x1F);
int word = map[windex];
int result = (word & mask) == 0 ? 0
: 1;
map[windex] = (word | mask);
return result;
} | [
"public",
"int",
"set",
"(",
"int",
"pos",
")",
"{",
"while",
"(",
"pos",
">=",
"capacity",
")",
"{",
"doubleCapacity",
"(",
")",
";",
"}",
"if",
"(",
"pos",
">=",
"limitPos",
")",
"{",
"limitPos",
"=",
"pos",
"+",
"1",
";",
"}",
"int",
"windex",... | Sets pos and returns old value | [
"Sets",
"pos",
"and",
"returns",
"old",
"value"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/store/BitMap.java#L83-L102 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/store/BitMap.java | BitMap.and | public static void and(byte[] map, int pos, byte source, int count) {
int shift = pos & 0x07;
int mask = (source & 0xff) >>> shift;
int innermask = 0xff >> shift;
int index = pos / 8;
if (count < 8) {
innermask = innermask >>> (8 - count);
innermask = innermask << (8 - count);
}
mask &= innermask;
innermask = ~innermask;
if (index >= map.length) {
return;
}
byte b = map[index];
map[index] = (byte) (b & innermask);
b = (byte) (b & mask);
map[index] = (byte) (map[index] | b);
if (shift == 0) {
return;
}
shift = 8 - shift;
if (count > shift) {
mask = ((source & 0xff) << 8) >>> shift;
innermask = 0xff00 >>> shift;
innermask = ~innermask;
b = map[index + 1];
map[index + 1] = (byte) (b & innermask);
b = (byte) (b & mask);
map[index + 1] = (byte) (map[index + 1] | b);
}
} | java | public static void and(byte[] map, int pos, byte source, int count) {
int shift = pos & 0x07;
int mask = (source & 0xff) >>> shift;
int innermask = 0xff >> shift;
int index = pos / 8;
if (count < 8) {
innermask = innermask >>> (8 - count);
innermask = innermask << (8 - count);
}
mask &= innermask;
innermask = ~innermask;
if (index >= map.length) {
return;
}
byte b = map[index];
map[index] = (byte) (b & innermask);
b = (byte) (b & mask);
map[index] = (byte) (map[index] | b);
if (shift == 0) {
return;
}
shift = 8 - shift;
if (count > shift) {
mask = ((source & 0xff) << 8) >>> shift;
innermask = 0xff00 >>> shift;
innermask = ~innermask;
b = map[index + 1];
map[index + 1] = (byte) (b & innermask);
b = (byte) (b & mask);
map[index + 1] = (byte) (map[index + 1] | b);
}
} | [
"public",
"static",
"void",
"and",
"(",
"byte",
"[",
"]",
"map",
",",
"int",
"pos",
",",
"byte",
"source",
",",
"int",
"count",
")",
"{",
"int",
"shift",
"=",
"pos",
"&",
"0x07",
";",
"int",
"mask",
"=",
"(",
"source",
"&",
"0xff",
")",
">>>",
... | AND count bits from source with map contents starting at pos | [
"AND",
"count",
"bits",
"from",
"source",
"with",
"map",
"contents",
"starting",
"at",
"pos"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/store/BitMap.java#L307-L347 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/store/BitMap.java | BitMap.or | public static void or(byte[] map, int pos, byte source, int count) {
int shift = pos & 0x07;
int mask = (source & 0xff) >>> shift;
int index = pos / 8;
if (index >= map.length) {
return;
}
byte b = (byte) (map[index] | mask);
map[index] = b;
if (shift == 0) {
return;
}
shift = 8 - shift;
if (count > shift) {
mask = ((source & 0xff) << 8) >>> shift;
b = (byte) (map[index + 1] | mask);
map[index + 1] = b;
}
} | java | public static void or(byte[] map, int pos, byte source, int count) {
int shift = pos & 0x07;
int mask = (source & 0xff) >>> shift;
int index = pos / 8;
if (index >= map.length) {
return;
}
byte b = (byte) (map[index] | mask);
map[index] = b;
if (shift == 0) {
return;
}
shift = 8 - shift;
if (count > shift) {
mask = ((source & 0xff) << 8) >>> shift;
b = (byte) (map[index + 1] | mask);
map[index + 1] = b;
}
} | [
"public",
"static",
"void",
"or",
"(",
"byte",
"[",
"]",
"map",
",",
"int",
"pos",
",",
"byte",
"source",
",",
"int",
"count",
")",
"{",
"int",
"shift",
"=",
"pos",
"&",
"0x07",
";",
"int",
"mask",
"=",
"(",
"source",
"&",
"0xff",
")",
">>>",
"... | OR count bits from source with map contents starting at pos | [
"OR",
"count",
"bits",
"from",
"source",
"with",
"map",
"contents",
"starting",
"at",
"pos"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/store/BitMap.java#L352-L377 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/lib/DoubleIntIndex.java | DoubleIntIndex.addUnsorted | public synchronized boolean addUnsorted(int key, int value) {
if (count == capacity) {
if (fixedSize) {
return false;
} else {
doubleCapacity();
}
}
if (sorted && count != 0) {
if (sortOnValues) {
if (value < values[count - 1]) {
sorted = false;
}
} else {
if (value < keys[count - 1]) {
sorted = false;
}
}
}
hasChanged = true;
keys[count] = key;
values[count] = value;
count++;
return true;
} | java | public synchronized boolean addUnsorted(int key, int value) {
if (count == capacity) {
if (fixedSize) {
return false;
} else {
doubleCapacity();
}
}
if (sorted && count != 0) {
if (sortOnValues) {
if (value < values[count - 1]) {
sorted = false;
}
} else {
if (value < keys[count - 1]) {
sorted = false;
}
}
}
hasChanged = true;
keys[count] = key;
values[count] = value;
count++;
return true;
} | [
"public",
"synchronized",
"boolean",
"addUnsorted",
"(",
"int",
"key",
",",
"int",
"value",
")",
"{",
"if",
"(",
"count",
"==",
"capacity",
")",
"{",
"if",
"(",
"fixedSize",
")",
"{",
"return",
"false",
";",
"}",
"else",
"{",
"doubleCapacity",
"(",
")"... | Adds a pair into the table.
@param key the key
@param value the value
@return true or false depending on success | [
"Adds",
"a",
"pair",
"into",
"the",
"table",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/lib/DoubleIntIndex.java#L145-L174 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/lib/DoubleIntIndex.java | DoubleIntIndex.addUnique | public synchronized boolean addUnique(int key, int value) {
if (count == capacity) {
if (fixedSize) {
return false;
} else {
doubleCapacity();
}
}
if (!sorted) {
fastQuickSort();
}
targetSearchValue = sortOnValues ? value
: key;
int i = binaryEmptySlotSearch();
if (i == -1) {
return false;
}
hasChanged = true;
if (count != i) {
moveRows(i, i + 1, count - i);
}
keys[i] = key;
values[i] = value;
count++;
return true;
} | java | public synchronized boolean addUnique(int key, int value) {
if (count == capacity) {
if (fixedSize) {
return false;
} else {
doubleCapacity();
}
}
if (!sorted) {
fastQuickSort();
}
targetSearchValue = sortOnValues ? value
: key;
int i = binaryEmptySlotSearch();
if (i == -1) {
return false;
}
hasChanged = true;
if (count != i) {
moveRows(i, i + 1, count - i);
}
keys[i] = key;
values[i] = value;
count++;
return true;
} | [
"public",
"synchronized",
"boolean",
"addUnique",
"(",
"int",
"key",
",",
"int",
"value",
")",
"{",
"if",
"(",
"count",
"==",
"capacity",
")",
"{",
"if",
"(",
"fixedSize",
")",
"{",
"return",
"false",
";",
"}",
"else",
"{",
"doubleCapacity",
"(",
")",
... | Adds a pair, ensuring no duplicate key xor value already exists in the
current search target column.
@param key the key
@param value the value
@return true or false depending on success | [
"Adds",
"a",
"pair",
"ensuring",
"no",
"duplicate",
"key",
"xor",
"value",
"already",
"exists",
"in",
"the",
"current",
"search",
"target",
"column",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/lib/DoubleIntIndex.java#L215-L250 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/lib/DoubleIntIndex.java | DoubleIntIndex.binaryFirstSearch | private int binaryFirstSearch() {
int low = 0;
int high = count;
int mid = 0;
int compare = 0;
int found = count;
while (low < high) {
mid = (low + high) / 2;
compare = compare(mid);
if (compare < 0) {
high = mid;
} else if (compare > 0) {
low = mid + 1;
} else {
high = mid;
found = mid;
}
}
return found == count ? -1
: found;
} | java | private int binaryFirstSearch() {
int low = 0;
int high = count;
int mid = 0;
int compare = 0;
int found = count;
while (low < high) {
mid = (low + high) / 2;
compare = compare(mid);
if (compare < 0) {
high = mid;
} else if (compare > 0) {
low = mid + 1;
} else {
high = mid;
found = mid;
}
}
return found == count ? -1
: found;
} | [
"private",
"int",
"binaryFirstSearch",
"(",
")",
"{",
"int",
"low",
"=",
"0",
";",
"int",
"high",
"=",
"count",
";",
"int",
"mid",
"=",
"0",
";",
"int",
"compare",
"=",
"0",
";",
"int",
"found",
"=",
"count",
";",
"while",
"(",
"low",
"<",
"high"... | Returns the index of the lowest element == the given search target,
or -1
@return index or -1 if not found | [
"Returns",
"the",
"index",
"of",
"the",
"lowest",
"element",
"==",
"the",
"given",
"search",
"target",
"or",
"-",
"1"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/lib/DoubleIntIndex.java#L398-L422 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/lib/DoubleIntIndex.java | DoubleIntIndex.binaryGreaterSearch | private int binaryGreaterSearch() {
int low = 0;
int high = count;
int mid = 0;
int compare = 0;
while (low < high) {
mid = (low + high) / 2;
compare = compare(mid);
if (compare < 0) {
high = mid;
} else {
low = mid + 1;
}
}
return low == count ? -1
: low;
} | java | private int binaryGreaterSearch() {
int low = 0;
int high = count;
int mid = 0;
int compare = 0;
while (low < high) {
mid = (low + high) / 2;
compare = compare(mid);
if (compare < 0) {
high = mid;
} else {
low = mid + 1;
}
}
return low == count ? -1
: low;
} | [
"private",
"int",
"binaryGreaterSearch",
"(",
")",
"{",
"int",
"low",
"=",
"0",
";",
"int",
"high",
"=",
"count",
";",
"int",
"mid",
"=",
"0",
";",
"int",
"compare",
"=",
"0",
";",
"while",
"(",
"low",
"<",
"high",
")",
"{",
"mid",
"=",
"(",
"l... | Returns the index of the lowest element > the given search target
@return the index | [
"Returns",
"the",
"index",
"of",
"the",
"lowest",
"element",
">",
"the",
"given",
"search",
"target"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/lib/DoubleIntIndex.java#L428-L448 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/lib/DoubleIntIndex.java | DoubleIntIndex.binarySlotSearch | private int binarySlotSearch() {
int low = 0;
int high = count;
int mid = 0;
int compare = 0;
while (low < high) {
mid = (low + high) / 2;
compare = compare(mid);
if (compare <= 0) {
high = mid;
} else {
low = mid + 1;
}
}
return low;
} | java | private int binarySlotSearch() {
int low = 0;
int high = count;
int mid = 0;
int compare = 0;
while (low < high) {
mid = (low + high) / 2;
compare = compare(mid);
if (compare <= 0) {
high = mid;
} else {
low = mid + 1;
}
}
return low;
} | [
"private",
"int",
"binarySlotSearch",
"(",
")",
"{",
"int",
"low",
"=",
"0",
";",
"int",
"high",
"=",
"count",
";",
"int",
"mid",
"=",
"0",
";",
"int",
"compare",
"=",
"0",
";",
"while",
"(",
"low",
"<",
"high",
")",
"{",
"mid",
"=",
"(",
"low"... | Returns the index of the lowest element >= the given search target,
or count
@return the index | [
"Returns",
"the",
"index",
"of",
"the",
"lowest",
"element",
">",
"=",
"the",
"given",
"search",
"target",
"or",
"count"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/lib/DoubleIntIndex.java#L455-L474 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/lib/DoubleIntIndex.java | DoubleIntIndex.binaryEmptySlotSearch | private int binaryEmptySlotSearch() {
int low = 0;
int high = count;
int mid = 0;
int compare = 0;
while (low < high) {
mid = (low + high) / 2;
compare = compare(mid);
if (compare < 0) {
high = mid;
} else if (compare > 0) {
low = mid + 1;
} else {
return -1;
}
}
return low;
} | java | private int binaryEmptySlotSearch() {
int low = 0;
int high = count;
int mid = 0;
int compare = 0;
while (low < high) {
mid = (low + high) / 2;
compare = compare(mid);
if (compare < 0) {
high = mid;
} else if (compare > 0) {
low = mid + 1;
} else {
return -1;
}
}
return low;
} | [
"private",
"int",
"binaryEmptySlotSearch",
"(",
")",
"{",
"int",
"low",
"=",
"0",
";",
"int",
"high",
"=",
"count",
";",
"int",
"mid",
"=",
"0",
";",
"int",
"compare",
"=",
"0",
";",
"while",
"(",
"low",
"<",
"high",
")",
"{",
"mid",
"=",
"(",
... | Returns the index of the lowest element > the given search target
or count or -1 if target is found
@return the index | [
"Returns",
"the",
"index",
"of",
"the",
"lowest",
"element",
">",
"the",
"given",
"search",
"target",
"or",
"count",
"or",
"-",
"1",
"if",
"target",
"is",
"found"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/lib/DoubleIntIndex.java#L481-L502 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/lib/DoubleIntIndex.java | DoubleIntIndex.compare | private int compare(int i) {
if (sortOnValues) {
if (targetSearchValue > values[i]) {
return 1;
} else if (targetSearchValue < values[i]) {
return -1;
}
} else {
if (targetSearchValue > keys[i]) {
return 1;
} else if (targetSearchValue < keys[i]) {
return -1;
}
}
return 0;
} | java | private int compare(int i) {
if (sortOnValues) {
if (targetSearchValue > values[i]) {
return 1;
} else if (targetSearchValue < values[i]) {
return -1;
}
} else {
if (targetSearchValue > keys[i]) {
return 1;
} else if (targetSearchValue < keys[i]) {
return -1;
}
}
return 0;
} | [
"private",
"int",
"compare",
"(",
"int",
"i",
")",
"{",
"if",
"(",
"sortOnValues",
")",
"{",
"if",
"(",
"targetSearchValue",
">",
"values",
"[",
"i",
"]",
")",
"{",
"return",
"1",
";",
"}",
"else",
"if",
"(",
"targetSearchValue",
"<",
"values",
"[",
... | Check if targeted column value in the row indexed i is less than the
search target object.
@param i the index
@return -1, 0 or +1 | [
"Check",
"if",
"targeted",
"column",
"value",
"in",
"the",
"row",
"indexed",
"i",
"is",
"less",
"than",
"the",
"search",
"target",
"object",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/lib/DoubleIntIndex.java#L634-L651 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/lib/DoubleIntIndex.java | DoubleIntIndex.lessThan | private boolean lessThan(int i, int j) {
if (sortOnValues) {
if (values[i] < values[j]) {
return true;
}
} else {
if (keys[i] < keys[j]) {
return true;
}
}
return false;
} | java | private boolean lessThan(int i, int j) {
if (sortOnValues) {
if (values[i] < values[j]) {
return true;
}
} else {
if (keys[i] < keys[j]) {
return true;
}
}
return false;
} | [
"private",
"boolean",
"lessThan",
"(",
"int",
"i",
",",
"int",
"j",
")",
"{",
"if",
"(",
"sortOnValues",
")",
"{",
"if",
"(",
"values",
"[",
"i",
"]",
"<",
"values",
"[",
"j",
"]",
")",
"{",
"return",
"true",
";",
"}",
"}",
"else",
"{",
"if",
... | Check if row indexed i is less than row indexed j
@param i the first index
@param j the second index
@return true or false | [
"Check",
"if",
"row",
"indexed",
"i",
"is",
"less",
"than",
"row",
"indexed",
"j"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/lib/DoubleIntIndex.java#L671-L684 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/util/FontDialogSwing.java | FontDialogSwing.setFontSize | public static void setFontSize(String inFontSize) {
// weconsultants@users 20050215 - Changed for Compatbilty fix for JDK 1.3
// Convert Strng to float for deriveFont() call
Float stageFloat = new Float(inFontSize);
float fontSize = stageFloat.floatValue();
Font fonttTree = fOwner.tTree.getFont().deriveFont(fontSize);
fOwner.tTree.setFont(fonttTree);
Font fontTxtCommand =
fOwner.txtCommand.getFont().deriveFont(fontSize);
fOwner.txtCommand.setFont(fontTxtCommand);
Font fontTxtResult = fOwner.txtResult.getFont().deriveFont(fontSize);
fOwner.txtResult.setFont(fontTxtResult);
} | java | public static void setFontSize(String inFontSize) {
// weconsultants@users 20050215 - Changed for Compatbilty fix for JDK 1.3
// Convert Strng to float for deriveFont() call
Float stageFloat = new Float(inFontSize);
float fontSize = stageFloat.floatValue();
Font fonttTree = fOwner.tTree.getFont().deriveFont(fontSize);
fOwner.tTree.setFont(fonttTree);
Font fontTxtCommand =
fOwner.txtCommand.getFont().deriveFont(fontSize);
fOwner.txtCommand.setFont(fontTxtCommand);
Font fontTxtResult = fOwner.txtResult.getFont().deriveFont(fontSize);
fOwner.txtResult.setFont(fontTxtResult);
} | [
"public",
"static",
"void",
"setFontSize",
"(",
"String",
"inFontSize",
")",
"{",
"// weconsultants@users 20050215 - Changed for Compatbilty fix for JDK 1.3",
"// Convert Strng to float for deriveFont() call",
"Float",
"stageFloat",
"=",
"new",
"Float",
"(",
"inFontSize",
")",
... | Displays a color chooser and Sets the selected color. | [
"Displays",
"a",
"color",
"chooser",
"and",
"Sets",
"the",
"selected",
"color",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/util/FontDialogSwing.java#L260-L278 | train |
VoltDB/voltdb | third_party/java/src/org/spearce_voltpatches/jgit/transport/OpenSshConfig.java | OpenSshConfig.lookup | public Host lookup(final String hostName) {
final Map<String, Host> cache = this.refresh();
Host h = cache.get(hostName);
if(h == null) {
h = new Host();
}
if(h.patternsApplied) {
return h;
}
for(final Map.Entry<String, Host> e : cache.entrySet()) {
if(!isHostPattern(e.getKey())) {
continue;
}
if(!isHostMatch(e.getKey(), hostName)) {
continue;
}
//log.debug("Found host match in SSH config:" + e.getValue());
h.copyFrom(e.getValue());
}
if(h.port == 0) {
h.port = -1;
}
h.patternsApplied = true;
return h;
} | java | public Host lookup(final String hostName) {
final Map<String, Host> cache = this.refresh();
Host h = cache.get(hostName);
if(h == null) {
h = new Host();
}
if(h.patternsApplied) {
return h;
}
for(final Map.Entry<String, Host> e : cache.entrySet()) {
if(!isHostPattern(e.getKey())) {
continue;
}
if(!isHostMatch(e.getKey(), hostName)) {
continue;
}
//log.debug("Found host match in SSH config:" + e.getValue());
h.copyFrom(e.getValue());
}
if(h.port == 0) {
h.port = -1;
}
h.patternsApplied = true;
return h;
} | [
"public",
"Host",
"lookup",
"(",
"final",
"String",
"hostName",
")",
"{",
"final",
"Map",
"<",
"String",
",",
"Host",
">",
"cache",
"=",
"this",
".",
"refresh",
"(",
")",
";",
"Host",
"h",
"=",
"cache",
".",
"get",
"(",
"hostName",
")",
";",
"if",
... | Locate the configuration for a specific host request.
@param hostName the name the user has supplied to the SSH tool. This may be a
real host name, or it may just be a "Host" block in the
configuration file.
@return r configuration for the requested name. Never null. | [
"Locate",
"the",
"configuration",
"for",
"a",
"specific",
"host",
"request",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/spearce_voltpatches/jgit/transport/OpenSshConfig.java#L103-L128 | train |
VoltDB/voltdb | src/frontend/org/voltcore/utils/CoreUtils.java | CoreUtils.getCachedSingleThreadExecutor | public static ListeningExecutorService getCachedSingleThreadExecutor(String name, long keepAlive) {
return MoreExecutors.listeningDecorator(new ThreadPoolExecutor(
0,
1,
keepAlive,
TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(),
CoreUtils.getThreadFactory(null, name, SMALL_STACK_SIZE, false, null)));
} | java | public static ListeningExecutorService getCachedSingleThreadExecutor(String name, long keepAlive) {
return MoreExecutors.listeningDecorator(new ThreadPoolExecutor(
0,
1,
keepAlive,
TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(),
CoreUtils.getThreadFactory(null, name, SMALL_STACK_SIZE, false, null)));
} | [
"public",
"static",
"ListeningExecutorService",
"getCachedSingleThreadExecutor",
"(",
"String",
"name",
",",
"long",
"keepAlive",
")",
"{",
"return",
"MoreExecutors",
".",
"listeningDecorator",
"(",
"new",
"ThreadPoolExecutor",
"(",
"0",
",",
"1",
",",
"keepAlive",
... | Get a single thread executor that caches its thread meaning that the thread will terminate
after keepAlive milliseconds. A new thread will be created the next time a task arrives and that will be kept
around for keepAlive milliseconds. On creation no thread is allocated, the first task creates a thread.
Uses LinkedTransferQueue to accept tasks and has a small stack. | [
"Get",
"a",
"single",
"thread",
"executor",
"that",
"caches",
"its",
"thread",
"meaning",
"that",
"the",
"thread",
"will",
"terminate",
"after",
"keepAlive",
"milliseconds",
".",
"A",
"new",
"thread",
"will",
"be",
"created",
"the",
"next",
"time",
"a",
"tas... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltcore/utils/CoreUtils.java#L429-L437 | train |
VoltDB/voltdb | src/frontend/org/voltcore/utils/CoreUtils.java | CoreUtils.getBoundedSingleThreadExecutor | public static ListeningExecutorService getBoundedSingleThreadExecutor(String name, int capacity) {
LinkedBlockingQueue<Runnable> lbq = new LinkedBlockingQueue<Runnable>(capacity);
ThreadPoolExecutor tpe =
new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, lbq, CoreUtils.getThreadFactory(name));
return MoreExecutors.listeningDecorator(tpe);
} | java | public static ListeningExecutorService getBoundedSingleThreadExecutor(String name, int capacity) {
LinkedBlockingQueue<Runnable> lbq = new LinkedBlockingQueue<Runnable>(capacity);
ThreadPoolExecutor tpe =
new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, lbq, CoreUtils.getThreadFactory(name));
return MoreExecutors.listeningDecorator(tpe);
} | [
"public",
"static",
"ListeningExecutorService",
"getBoundedSingleThreadExecutor",
"(",
"String",
"name",
",",
"int",
"capacity",
")",
"{",
"LinkedBlockingQueue",
"<",
"Runnable",
">",
"lbq",
"=",
"new",
"LinkedBlockingQueue",
"<",
"Runnable",
">",
"(",
"capacity",
"... | Create a bounded single threaded executor that rejects requests if more than capacity
requests are outstanding. | [
"Create",
"a",
"bounded",
"single",
"threaded",
"executor",
"that",
"rejects",
"requests",
"if",
"more",
"than",
"capacity",
"requests",
"are",
"outstanding",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltcore/utils/CoreUtils.java#L485-L490 | train |
VoltDB/voltdb | src/frontend/org/voltcore/utils/CoreUtils.java | CoreUtils.getBoundedThreadPoolExecutor | public static ThreadPoolExecutor getBoundedThreadPoolExecutor(int maxPoolSize, long keepAliveTime, TimeUnit unit, ThreadFactory tFactory) {
return new ThreadPoolExecutor(0, maxPoolSize, keepAliveTime, unit,
new SynchronousQueue<Runnable>(), tFactory);
} | java | public static ThreadPoolExecutor getBoundedThreadPoolExecutor(int maxPoolSize, long keepAliveTime, TimeUnit unit, ThreadFactory tFactory) {
return new ThreadPoolExecutor(0, maxPoolSize, keepAliveTime, unit,
new SynchronousQueue<Runnable>(), tFactory);
} | [
"public",
"static",
"ThreadPoolExecutor",
"getBoundedThreadPoolExecutor",
"(",
"int",
"maxPoolSize",
",",
"long",
"keepAliveTime",
",",
"TimeUnit",
"unit",
",",
"ThreadFactory",
"tFactory",
")",
"{",
"return",
"new",
"ThreadPoolExecutor",
"(",
"0",
",",
"maxPoolSize",... | Create a bounded thread pool executor. The work queue is synchronous and can cause
RejectedExecutionException if there is no available thread to take a new task.
@param maxPoolSize: the maximum number of threads to allow in the pool.
@param keepAliveTime: when the number of threads is greater than the core, this is the maximum
time that excess idle threads will wait for new tasks before terminating.
@param unit: the time unit for the keepAliveTime argument.
@param threadFactory: the factory to use when the executor creates a new thread. | [
"Create",
"a",
"bounded",
"thread",
"pool",
"executor",
".",
"The",
"work",
"queue",
"is",
"synchronous",
"and",
"can",
"cause",
"RejectedExecutionException",
"if",
"there",
"is",
"no",
"available",
"thread",
"to",
"take",
"a",
"new",
"task",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltcore/utils/CoreUtils.java#L588-L591 | train |
VoltDB/voltdb | src/frontend/org/voltcore/utils/CoreUtils.java | CoreUtils.getQueueingExecutorService | public static ExecutorService getQueueingExecutorService(final Queue<Runnable> taskQueue) {
return new ExecutorService() {
@Override
public void execute(Runnable command) {
taskQueue.offer(command);
}
@Override
public void shutdown() {
throw new UnsupportedOperationException();
}
@Override
public List<Runnable> shutdownNow() {
throw new UnsupportedOperationException();
}
@Override
public boolean isShutdown() {
return false;
}
@Override
public boolean isTerminated() {
return false;
}
@Override
public boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException {
return true;
}
@Override
public <T> Future<T> submit(Callable<T> task) {
Preconditions.checkNotNull(task);
FutureTask<T> retval = new FutureTask<T>(task);
taskQueue.offer(retval);
return retval;
}
@Override
public <T> Future<T> submit(Runnable task, T result) {
Preconditions.checkNotNull(task);
FutureTask<T> retval = new FutureTask<T>(task, result);
taskQueue.offer(retval);
return retval;
}
@Override
public Future<?> submit(Runnable task) {
Preconditions.checkNotNull(task);
ListenableFutureTask<Object> retval = ListenableFutureTask.create(task, null);
taskQueue.offer(retval);
return retval;
}
@Override
public <T> List<Future<T>> invokeAll(
Collection<? extends Callable<T>> tasks)
throws InterruptedException {
throw new UnsupportedOperationException();
}
@Override
public <T> List<Future<T>> invokeAll(
Collection<? extends Callable<T>> tasks, long timeout,
TimeUnit unit) throws InterruptedException {
throw new UnsupportedOperationException();
}
@Override
public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
throws InterruptedException, ExecutionException {
throw new UnsupportedOperationException();
}
@Override
public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit) throws InterruptedException,
ExecutionException, TimeoutException {
throw new UnsupportedOperationException();
}
};
} | java | public static ExecutorService getQueueingExecutorService(final Queue<Runnable> taskQueue) {
return new ExecutorService() {
@Override
public void execute(Runnable command) {
taskQueue.offer(command);
}
@Override
public void shutdown() {
throw new UnsupportedOperationException();
}
@Override
public List<Runnable> shutdownNow() {
throw new UnsupportedOperationException();
}
@Override
public boolean isShutdown() {
return false;
}
@Override
public boolean isTerminated() {
return false;
}
@Override
public boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException {
return true;
}
@Override
public <T> Future<T> submit(Callable<T> task) {
Preconditions.checkNotNull(task);
FutureTask<T> retval = new FutureTask<T>(task);
taskQueue.offer(retval);
return retval;
}
@Override
public <T> Future<T> submit(Runnable task, T result) {
Preconditions.checkNotNull(task);
FutureTask<T> retval = new FutureTask<T>(task, result);
taskQueue.offer(retval);
return retval;
}
@Override
public Future<?> submit(Runnable task) {
Preconditions.checkNotNull(task);
ListenableFutureTask<Object> retval = ListenableFutureTask.create(task, null);
taskQueue.offer(retval);
return retval;
}
@Override
public <T> List<Future<T>> invokeAll(
Collection<? extends Callable<T>> tasks)
throws InterruptedException {
throw new UnsupportedOperationException();
}
@Override
public <T> List<Future<T>> invokeAll(
Collection<? extends Callable<T>> tasks, long timeout,
TimeUnit unit) throws InterruptedException {
throw new UnsupportedOperationException();
}
@Override
public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
throws InterruptedException, ExecutionException {
throw new UnsupportedOperationException();
}
@Override
public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit) throws InterruptedException,
ExecutionException, TimeoutException {
throw new UnsupportedOperationException();
}
};
} | [
"public",
"static",
"ExecutorService",
"getQueueingExecutorService",
"(",
"final",
"Queue",
"<",
"Runnable",
">",
"taskQueue",
")",
"{",
"return",
"new",
"ExecutorService",
"(",
")",
"{",
"@",
"Override",
"public",
"void",
"execute",
"(",
"Runnable",
"command",
... | Create an ExceutorService that places tasks in an existing task queue for execution. Used
to create a bridge for using ListenableFutures in classes already built around a queue.
@param taskQueue : place to enqueue Runnables submitted to the service | [
"Create",
"an",
"ExceutorService",
"that",
"places",
"tasks",
"in",
"an",
"existing",
"task",
"queue",
"for",
"execution",
".",
"Used",
"to",
"create",
"a",
"bridge",
"for",
"using",
"ListenableFutures",
"in",
"classes",
"already",
"built",
"around",
"a",
"que... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltcore/utils/CoreUtils.java#L598-L682 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.