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 | third_party/java/src/com/google_voltpatches/common/util/concurrent/WrappingExecutorService.java | WrappingExecutorService.wrapTasks | private final <T> ImmutableList<Callable<T>> wrapTasks(Collection<? extends Callable<T>> tasks) {
ImmutableList.Builder<Callable<T>> builder = ImmutableList.builder();
for (Callable<T> task : tasks) {
builder.add(wrapTask(task));
}
return builder.build();
} | java | private final <T> ImmutableList<Callable<T>> wrapTasks(Collection<? extends Callable<T>> tasks) {
ImmutableList.Builder<Callable<T>> builder = ImmutableList.builder();
for (Callable<T> task : tasks) {
builder.add(wrapTask(task));
}
return builder.build();
} | [
"private",
"final",
"<",
"T",
">",
"ImmutableList",
"<",
"Callable",
"<",
"T",
">",
">",
"wrapTasks",
"(",
"Collection",
"<",
"?",
"extends",
"Callable",
"<",
"T",
">",
">",
"tasks",
")",
"{",
"ImmutableList",
".",
"Builder",
"<",
"Callable",
"<",
"T",... | Wraps a collection of tasks.
@throws NullPointerException if any element of {@code tasks} is null | [
"Wraps",
"a",
"collection",
"of",
"tasks",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/com/google_voltpatches/common/util/concurrent/WrappingExecutorService.java#L82-L88 | train |
VoltDB/voltdb | src/frontend/org/voltdb/LoadedProcedureSet.java | LoadedProcedureSet.loadProcedures | public void loadProcedures(CatalogContext catalogContext, boolean isInitOrReplay)
{
m_defaultProcManager = catalogContext.m_defaultProcs;
// default proc caches clear on catalog update
m_defaultProcCache.clear();
m_plannerTool = catalogContext.m_ptool;
// reload all system procedures from beginning
m_sysProcs = loadSystemProcedures(catalogContext, m_site);
try {
if (isInitOrReplay) {
// reload user procedures
m_userProcs = loadUserProcedureRunners(catalogContext.database.getProcedures(),
catalogContext.getCatalogJar().getLoader(),
null,
m_site);
} else {
// When catalog updates, only user procedures needs to be reloaded.
m_userProcs = catalogContext.getPreparedUserProcedureRunners(m_site);
}
} catch (Exception e) {
VoltDB.crashLocalVoltDB("Error trying to load user procedures: " + e.getMessage());
}
} | java | public void loadProcedures(CatalogContext catalogContext, boolean isInitOrReplay)
{
m_defaultProcManager = catalogContext.m_defaultProcs;
// default proc caches clear on catalog update
m_defaultProcCache.clear();
m_plannerTool = catalogContext.m_ptool;
// reload all system procedures from beginning
m_sysProcs = loadSystemProcedures(catalogContext, m_site);
try {
if (isInitOrReplay) {
// reload user procedures
m_userProcs = loadUserProcedureRunners(catalogContext.database.getProcedures(),
catalogContext.getCatalogJar().getLoader(),
null,
m_site);
} else {
// When catalog updates, only user procedures needs to be reloaded.
m_userProcs = catalogContext.getPreparedUserProcedureRunners(m_site);
}
} catch (Exception e) {
VoltDB.crashLocalVoltDB("Error trying to load user procedures: " + e.getMessage());
}
} | [
"public",
"void",
"loadProcedures",
"(",
"CatalogContext",
"catalogContext",
",",
"boolean",
"isInitOrReplay",
")",
"{",
"m_defaultProcManager",
"=",
"catalogContext",
".",
"m_defaultProcs",
";",
"// default proc caches clear on catalog update",
"m_defaultProcCache",
".",
"cl... | Load procedures. | [
"Load",
"procedures",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/LoadedProcedureSet.java#L94-L118 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLParser.java | SQLParser.makeInnerProcedureModifierClausePattern | private static SQLPatternPart makeInnerProcedureModifierClausePattern(boolean captureTokens)
{
return
SPF.oneOf(
SPF.clause(
SPF.token("allow"),
SPF.group(captureTokens, SPF.commaList(SPF.userName()))
),
SPF.clause(
SPF.token("partition"), SPF.token("on"), SPF.token("table"),
SPF.group(captureTokens, SPF.databaseObjectName()),
SPF.token("column"),
SPF.group(captureTokens, SPF.databaseObjectName()),
SPF.optional(
SPF.clause(
SPF.token("parameter"),
SPF.group(captureTokens, SPF.integer())
)
),
// parse a two-partition transaction clause
SPF.optional(
SPF.clause(
SPF.token("and"), SPF.token("on"), SPF.token("table"),
SPF.group(captureTokens, SPF.databaseObjectName()),
SPF.token("column"),
SPF.group(captureTokens, SPF.databaseObjectName()),
SPF.optional(
SPF.clause(
SPF.token("parameter"),
SPF.group(captureTokens, SPF.integer())
)
)
)
)
)
);
} | java | private static SQLPatternPart makeInnerProcedureModifierClausePattern(boolean captureTokens)
{
return
SPF.oneOf(
SPF.clause(
SPF.token("allow"),
SPF.group(captureTokens, SPF.commaList(SPF.userName()))
),
SPF.clause(
SPF.token("partition"), SPF.token("on"), SPF.token("table"),
SPF.group(captureTokens, SPF.databaseObjectName()),
SPF.token("column"),
SPF.group(captureTokens, SPF.databaseObjectName()),
SPF.optional(
SPF.clause(
SPF.token("parameter"),
SPF.group(captureTokens, SPF.integer())
)
),
// parse a two-partition transaction clause
SPF.optional(
SPF.clause(
SPF.token("and"), SPF.token("on"), SPF.token("table"),
SPF.group(captureTokens, SPF.databaseObjectName()),
SPF.token("column"),
SPF.group(captureTokens, SPF.databaseObjectName()),
SPF.optional(
SPF.clause(
SPF.token("parameter"),
SPF.group(captureTokens, SPF.integer())
)
)
)
)
)
);
} | [
"private",
"static",
"SQLPatternPart",
"makeInnerProcedureModifierClausePattern",
"(",
"boolean",
"captureTokens",
")",
"{",
"return",
"SPF",
".",
"oneOf",
"(",
"SPF",
".",
"clause",
"(",
"SPF",
".",
"token",
"(",
"\"allow\"",
")",
",",
"SPF",
".",
"group",
"(... | Build a pattern segment to accept a single optional ALLOW or PARTITION clause
to modify CREATE PROCEDURE statements.
@param captureTokens Capture individual tokens if true
@return Inner pattern to be wrapped by the caller as appropriate
Capture groups (when captureTokens is true):
(1) ALLOW clause: entire role list with commas and internal whitespace
(2) PARTITION clause: procedure name
(3) PARTITION clause: table name
(4) PARTITION clause: column name | [
"Build",
"a",
"pattern",
"segment",
"to",
"accept",
"a",
"single",
"optional",
"ALLOW",
"or",
"PARTITION",
"clause",
"to",
"modify",
"CREATE",
"PROCEDURE",
"statements",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLParser.java#L908-L944 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLParser.java | SQLParser.unparsedProcedureModifierClauses | static SQLPatternPart unparsedProcedureModifierClauses()
{
// Force the leading space to go inside the repeat block.
return SPF.capture(SPF.repeat(makeInnerProcedureModifierClausePattern(false))).withFlags(SQLPatternFactory.ADD_LEADING_SPACE_TO_CHILD);
} | java | static SQLPatternPart unparsedProcedureModifierClauses()
{
// Force the leading space to go inside the repeat block.
return SPF.capture(SPF.repeat(makeInnerProcedureModifierClausePattern(false))).withFlags(SQLPatternFactory.ADD_LEADING_SPACE_TO_CHILD);
} | [
"static",
"SQLPatternPart",
"unparsedProcedureModifierClauses",
"(",
")",
"{",
"// Force the leading space to go inside the repeat block.",
"return",
"SPF",
".",
"capture",
"(",
"SPF",
".",
"repeat",
"(",
"makeInnerProcedureModifierClausePattern",
"(",
"false",
")",
")",
")... | Build a pattern segment to recognize all the ALLOW or PARTITION modifier clauses
of a CREATE PROCEDURE statement.
@return Pattern to be used by the caller inside a CREATE PROCEDURE pattern.
Capture groups:
(1) All ALLOW/PARTITION modifier clauses as one string | [
"Build",
"a",
"pattern",
"segment",
"to",
"recognize",
"all",
"the",
"ALLOW",
"or",
"PARTITION",
"modifier",
"clauses",
"of",
"a",
"CREATE",
"PROCEDURE",
"statement",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLParser.java#L973-L977 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLParser.java | SQLParser.makeInnerStreamModifierClausePattern | private static SQLPatternPart makeInnerStreamModifierClausePattern(boolean captureTokens)
{
return
SPF.oneOf(
SPF.clause(
SPF.token("export"),SPF.token("to"),SPF.token("target"),
SPF.group(captureTokens, SPF.databaseObjectName())
),
SPF.clause(
SPF.token("partition"), SPF.token("on"), SPF.token("column"),
SPF.group(captureTokens, SPF.databaseObjectName())
)
);
} | java | private static SQLPatternPart makeInnerStreamModifierClausePattern(boolean captureTokens)
{
return
SPF.oneOf(
SPF.clause(
SPF.token("export"),SPF.token("to"),SPF.token("target"),
SPF.group(captureTokens, SPF.databaseObjectName())
),
SPF.clause(
SPF.token("partition"), SPF.token("on"), SPF.token("column"),
SPF.group(captureTokens, SPF.databaseObjectName())
)
);
} | [
"private",
"static",
"SQLPatternPart",
"makeInnerStreamModifierClausePattern",
"(",
"boolean",
"captureTokens",
")",
"{",
"return",
"SPF",
".",
"oneOf",
"(",
"SPF",
".",
"clause",
"(",
"SPF",
".",
"token",
"(",
"\"export\"",
")",
",",
"SPF",
".",
"token",
"(",... | Build a pattern segment to accept a single optional EXPORT or PARTITION clause
to modify CREATE STREAM statements.
@param captureTokens Capture individual tokens if true
@return Inner pattern to be wrapped by the caller as appropriate
Capture groups (when captureTokens is true):
(1) EXPORT clause: target name
(2) PARTITION clause: column name | [
"Build",
"a",
"pattern",
"segment",
"to",
"accept",
"a",
"single",
"optional",
"EXPORT",
"or",
"PARTITION",
"clause",
"to",
"modify",
"CREATE",
"STREAM",
"statements",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLParser.java#L990-L1003 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLParser.java | SQLParser.unparsedStreamModifierClauses | private static SQLPatternPart unparsedStreamModifierClauses() {
// Force the leading space to go inside the repeat block.
return SPF.capture(SPF.repeat(makeInnerStreamModifierClausePattern(false))).withFlags(SQLPatternFactory.ADD_LEADING_SPACE_TO_CHILD);
} | java | private static SQLPatternPart unparsedStreamModifierClauses() {
// Force the leading space to go inside the repeat block.
return SPF.capture(SPF.repeat(makeInnerStreamModifierClausePattern(false))).withFlags(SQLPatternFactory.ADD_LEADING_SPACE_TO_CHILD);
} | [
"private",
"static",
"SQLPatternPart",
"unparsedStreamModifierClauses",
"(",
")",
"{",
"// Force the leading space to go inside the repeat block.",
"return",
"SPF",
".",
"capture",
"(",
"SPF",
".",
"repeat",
"(",
"makeInnerStreamModifierClausePattern",
"(",
"false",
")",
")... | Build a pattern segment to recognize all the EXPORT or PARTITION modifier clauses
of a CREATE STREAM statement.
@return Pattern to be used by the caller inside a CREATE STREAM pattern.
Capture groups:
(1) All EXPORT/PARTITION modifier clauses as one string | [
"Build",
"a",
"pattern",
"segment",
"to",
"recognize",
"all",
"the",
"EXPORT",
"or",
"PARTITION",
"modifier",
"clauses",
"of",
"a",
"CREATE",
"STREAM",
"statement",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLParser.java#L1028-L1031 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLParser.java | SQLParser.parseExecParameters | private static List<String> parseExecParameters(String paramText)
{
final String SafeParamStringValuePattern = "#(SQL_PARSER_SAFE_PARAMSTRING)";
// Find all quoted strings.
// Mask out strings that contain whitespace or commas
// that must not be confused with parameter separators.
// "Safe" strings that don't contain these characters don't need to be masked
// but they DO need to be found and explicitly skipped so that their closing
// quotes don't trigger a false positive for the START of an unsafe string.
// Skipping is accomplished by resetting paramText to an offset substring
// after copying the skipped (or substituted) text to a string builder.
ArrayList<String> originalString = new ArrayList<>();
Matcher stringMatcher = SingleQuotedString.matcher(paramText);
StringBuilder safeText = new StringBuilder();
while (stringMatcher.find()) {
// Save anything before the found string.
safeText.append(paramText.substring(0, stringMatcher.start()));
String asMatched = stringMatcher.group();
if (SingleQuotedStringContainingParameterSeparators.matcher(asMatched).matches()) {
// The matched string is unsafe, provide cover for it in safeText.
originalString.add(asMatched);
safeText.append(SafeParamStringValuePattern);
} else {
// The matched string is safe. Add it to safeText.
safeText.append(asMatched);
}
paramText = paramText.substring(stringMatcher.end());
stringMatcher = SingleQuotedString.matcher(paramText);
}
// Save anything after the last found string.
safeText.append(paramText);
ArrayList<String> params = new ArrayList<>();
int subCount = 0;
int neededSubs = originalString.size();
// Split the params at the separators
String[] split = safeText.toString().split("[\\s,]+");
for (String fragment : split) {
if (fragment.isEmpty()) {
continue; // ignore effects of leading or trailing separators
}
// Replace each substitution in order exactly once.
if (subCount < neededSubs) {
// Substituted strings will normally take up an entire parameter,
// but some cases like parameters containing escaped single quotes
// may require multiple serial substitutions.
while (fragment.indexOf(SafeParamStringValuePattern) > -1) {
fragment = fragment.replace(SafeParamStringValuePattern,
originalString.get(subCount));
++subCount;
}
}
params.add(fragment);
}
assert(subCount == neededSubs);
return params;
} | java | private static List<String> parseExecParameters(String paramText)
{
final String SafeParamStringValuePattern = "#(SQL_PARSER_SAFE_PARAMSTRING)";
// Find all quoted strings.
// Mask out strings that contain whitespace or commas
// that must not be confused with parameter separators.
// "Safe" strings that don't contain these characters don't need to be masked
// but they DO need to be found and explicitly skipped so that their closing
// quotes don't trigger a false positive for the START of an unsafe string.
// Skipping is accomplished by resetting paramText to an offset substring
// after copying the skipped (or substituted) text to a string builder.
ArrayList<String> originalString = new ArrayList<>();
Matcher stringMatcher = SingleQuotedString.matcher(paramText);
StringBuilder safeText = new StringBuilder();
while (stringMatcher.find()) {
// Save anything before the found string.
safeText.append(paramText.substring(0, stringMatcher.start()));
String asMatched = stringMatcher.group();
if (SingleQuotedStringContainingParameterSeparators.matcher(asMatched).matches()) {
// The matched string is unsafe, provide cover for it in safeText.
originalString.add(asMatched);
safeText.append(SafeParamStringValuePattern);
} else {
// The matched string is safe. Add it to safeText.
safeText.append(asMatched);
}
paramText = paramText.substring(stringMatcher.end());
stringMatcher = SingleQuotedString.matcher(paramText);
}
// Save anything after the last found string.
safeText.append(paramText);
ArrayList<String> params = new ArrayList<>();
int subCount = 0;
int neededSubs = originalString.size();
// Split the params at the separators
String[] split = safeText.toString().split("[\\s,]+");
for (String fragment : split) {
if (fragment.isEmpty()) {
continue; // ignore effects of leading or trailing separators
}
// Replace each substitution in order exactly once.
if (subCount < neededSubs) {
// Substituted strings will normally take up an entire parameter,
// but some cases like parameters containing escaped single quotes
// may require multiple serial substitutions.
while (fragment.indexOf(SafeParamStringValuePattern) > -1) {
fragment = fragment.replace(SafeParamStringValuePattern,
originalString.get(subCount));
++subCount;
}
}
params.add(fragment);
}
assert(subCount == neededSubs);
return params;
} | [
"private",
"static",
"List",
"<",
"String",
">",
"parseExecParameters",
"(",
"String",
"paramText",
")",
"{",
"final",
"String",
"SafeParamStringValuePattern",
"=",
"\"#(SQL_PARSER_SAFE_PARAMSTRING)\"",
";",
"// Find all quoted strings.",
"// Mask out strings that contain white... | to the extent that comments are supported they have already been stripped out. | [
"to",
"the",
"extent",
"that",
"comments",
"are",
"supported",
"they",
"have",
"already",
"been",
"stripped",
"out",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLParser.java#L1132-L1188 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLParser.java | SQLParser.parseRecallStatement | public static ParseRecallResults parseRecallStatement(String statement, int lineMax)
{
Matcher matcher = RecallToken.matcher(statement);
if (matcher.matches()) {
String commandWordTerminator = matcher.group(1);
String lineNumberText = matcher.group(2);
String error;
if (OneWhitespace.matcher(commandWordTerminator).matches()) {
String trailings = matcher.group(3) + ";" + matcher.group(4);
// In a valid command, both "trailings" groups should be empty.
if (trailings.equals(";")) {
try {
int line = Integer.parseInt(lineNumberText) - 1;
if (line < 0 || line > lineMax) {
throw new NumberFormatException();
}
// Return the recall line number.
return new ParseRecallResults(line);
}
catch (NumberFormatException e) {
error = "Invalid RECALL line number argument: '" + lineNumberText + "'";
}
}
// For an invalid form of the command,
// return an approximation of the garbage input.
else {
error = "Invalid RECALL line number argument: '" +
lineNumberText + " " + trailings + "'";
}
}
else if (commandWordTerminator.equals("") || commandWordTerminator.equals(";")) {
error = "Incomplete RECALL command. RECALL expects a line number argument.";
} else {
error = "Invalid RECALL command: a space and line number are required after 'recall'";
}
return new ParseRecallResults(error);
}
return null;
} | java | public static ParseRecallResults parseRecallStatement(String statement, int lineMax)
{
Matcher matcher = RecallToken.matcher(statement);
if (matcher.matches()) {
String commandWordTerminator = matcher.group(1);
String lineNumberText = matcher.group(2);
String error;
if (OneWhitespace.matcher(commandWordTerminator).matches()) {
String trailings = matcher.group(3) + ";" + matcher.group(4);
// In a valid command, both "trailings" groups should be empty.
if (trailings.equals(";")) {
try {
int line = Integer.parseInt(lineNumberText) - 1;
if (line < 0 || line > lineMax) {
throw new NumberFormatException();
}
// Return the recall line number.
return new ParseRecallResults(line);
}
catch (NumberFormatException e) {
error = "Invalid RECALL line number argument: '" + lineNumberText + "'";
}
}
// For an invalid form of the command,
// return an approximation of the garbage input.
else {
error = "Invalid RECALL line number argument: '" +
lineNumberText + " " + trailings + "'";
}
}
else if (commandWordTerminator.equals("") || commandWordTerminator.equals(";")) {
error = "Incomplete RECALL command. RECALL expects a line number argument.";
} else {
error = "Invalid RECALL command: a space and line number are required after 'recall'";
}
return new ParseRecallResults(error);
}
return null;
} | [
"public",
"static",
"ParseRecallResults",
"parseRecallStatement",
"(",
"String",
"statement",
",",
"int",
"lineMax",
")",
"{",
"Matcher",
"matcher",
"=",
"RecallToken",
".",
"matcher",
"(",
"statement",
")",
";",
"if",
"(",
"matcher",
".",
"matches",
"(",
")",... | Parse RECALL statement for sqlcmd.
@param statement statement to parse
@param lineMax maximum line # + 1
@return results object or NULL if statement wasn't recognized | [
"Parse",
"RECALL",
"statement",
"for",
"sqlcmd",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLParser.java#L1244-L1282 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLParser.java | SQLParser.parseFileStatement | public static List<FileInfo> parseFileStatement(FileInfo parentContext, String statement)
{
Matcher fileMatcher = FileToken.matcher(statement);
if (! fileMatcher.lookingAt()) {
// This input does not start with FILE,
// so it's not a file command, it's something else.
// Return to caller a null and no errors.
return null;
}
String remainder = statement.substring(fileMatcher.end(), statement.length());
List<FileInfo> filesInfo = new ArrayList<>();
Matcher inlineBatchMatcher = DashInlineBatchToken.matcher(remainder);
if (inlineBatchMatcher.lookingAt()) {
remainder = remainder.substring(inlineBatchMatcher.end(), remainder.length());
Matcher delimiterMatcher = DelimiterToken.matcher(remainder);
// use matches here (not lookingAt) because we want to match
// all of the remainder, not just beginning
if (delimiterMatcher.matches()) {
String delimiter = delimiterMatcher.group(1);
filesInfo.add(new FileInfo(parentContext, FileOption.INLINEBATCH, delimiter));
return filesInfo;
}
throw new SQLParser.Exception(
"Did not find valid delimiter for \"file -inlinebatch\" command.");
}
// It is either a plain or a -batch file command.
FileOption option = FileOption.PLAIN;
Matcher batchMatcher = DashBatchToken.matcher(remainder);
if (batchMatcher.lookingAt()) {
option = FileOption.BATCH;
remainder = remainder.substring(batchMatcher.end(), remainder.length());
}
// remove spaces before and after filenames
remainder = remainder.trim();
// split filenames assuming they are separated by space ignoring spaces within quotes
// tests for parsing in TestSqlCmdInterface.java
List<String> filenames = new ArrayList<>();
Pattern regex = Pattern.compile("[^\\s\']+|'[^']*'");
Matcher regexMatcher = regex.matcher(remainder);
while (regexMatcher.find()) {
filenames.add(regexMatcher.group());
}
for (String filename : filenames) {
Matcher filenameMatcher = FilenameToken.matcher(filename);
// Use matches to match all input, not just beginning
if (filenameMatcher.matches()) {
filename = filenameMatcher.group(1);
// Trim whitespace from beginning and end of the file name.
// User may have wanted quoted whitespace at the beginning or end
// of the file name, but that seems very unlikely.
filename = filename.trim();
if (filename.startsWith("~")) {
filename = filename.replaceFirst("~", System.getProperty("user.home"));
}
filesInfo.add(new FileInfo(parentContext, option, filename));
}
}
// If no filename, or a filename of only spaces, then throw an error.
if ( filesInfo.size() == 0 ) {
String msg = String.format("Did not find valid file name in \"file%s\" command.",
option == FileOption.BATCH ? " -batch" : "");
throw new SQLParser.Exception(msg);
}
return filesInfo;
} | java | public static List<FileInfo> parseFileStatement(FileInfo parentContext, String statement)
{
Matcher fileMatcher = FileToken.matcher(statement);
if (! fileMatcher.lookingAt()) {
// This input does not start with FILE,
// so it's not a file command, it's something else.
// Return to caller a null and no errors.
return null;
}
String remainder = statement.substring(fileMatcher.end(), statement.length());
List<FileInfo> filesInfo = new ArrayList<>();
Matcher inlineBatchMatcher = DashInlineBatchToken.matcher(remainder);
if (inlineBatchMatcher.lookingAt()) {
remainder = remainder.substring(inlineBatchMatcher.end(), remainder.length());
Matcher delimiterMatcher = DelimiterToken.matcher(remainder);
// use matches here (not lookingAt) because we want to match
// all of the remainder, not just beginning
if (delimiterMatcher.matches()) {
String delimiter = delimiterMatcher.group(1);
filesInfo.add(new FileInfo(parentContext, FileOption.INLINEBATCH, delimiter));
return filesInfo;
}
throw new SQLParser.Exception(
"Did not find valid delimiter for \"file -inlinebatch\" command.");
}
// It is either a plain or a -batch file command.
FileOption option = FileOption.PLAIN;
Matcher batchMatcher = DashBatchToken.matcher(remainder);
if (batchMatcher.lookingAt()) {
option = FileOption.BATCH;
remainder = remainder.substring(batchMatcher.end(), remainder.length());
}
// remove spaces before and after filenames
remainder = remainder.trim();
// split filenames assuming they are separated by space ignoring spaces within quotes
// tests for parsing in TestSqlCmdInterface.java
List<String> filenames = new ArrayList<>();
Pattern regex = Pattern.compile("[^\\s\']+|'[^']*'");
Matcher regexMatcher = regex.matcher(remainder);
while (regexMatcher.find()) {
filenames.add(regexMatcher.group());
}
for (String filename : filenames) {
Matcher filenameMatcher = FilenameToken.matcher(filename);
// Use matches to match all input, not just beginning
if (filenameMatcher.matches()) {
filename = filenameMatcher.group(1);
// Trim whitespace from beginning and end of the file name.
// User may have wanted quoted whitespace at the beginning or end
// of the file name, but that seems very unlikely.
filename = filename.trim();
if (filename.startsWith("~")) {
filename = filename.replaceFirst("~", System.getProperty("user.home"));
}
filesInfo.add(new FileInfo(parentContext, option, filename));
}
}
// If no filename, or a filename of only spaces, then throw an error.
if ( filesInfo.size() == 0 ) {
String msg = String.format("Did not find valid file name in \"file%s\" command.",
option == FileOption.BATCH ? " -batch" : "");
throw new SQLParser.Exception(msg);
}
return filesInfo;
} | [
"public",
"static",
"List",
"<",
"FileInfo",
">",
"parseFileStatement",
"(",
"FileInfo",
"parentContext",
",",
"String",
"statement",
")",
"{",
"Matcher",
"fileMatcher",
"=",
"FileToken",
".",
"matcher",
"(",
"statement",
")",
";",
"if",
"(",
"!",
"fileMatcher... | Parse FILE statement for sqlcmd.
@param fileInfo optional parent file context for better diagnostics.
@param statement statement to parse
@return File object or NULL if statement wasn't recognized | [
"Parse",
"FILE",
"statement",
"for",
"sqlcmd",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLParser.java#L1411-L1489 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLParser.java | SQLParser.parseShowStatementSubcommand | public static String parseShowStatementSubcommand(String statement)
{
Matcher matcher = ShowToken.matcher(statement);
if (matcher.matches()) {
String commandWordTerminator = matcher.group(1);
if (OneWhitespace.matcher(commandWordTerminator).matches()) {
String trailings = matcher.group(3) + ";" + matcher.group(4);
// In a valid command, both "trailings" groups should be empty.
if (trailings.equals(";")) {
// Return the subcommand keyword -- possibly a valid one.
return matcher.group(2);
}
// For an invalid form of the command,
// return an approximation of the garbage input.
return matcher.group(2) + " " + trailings;
}
if (commandWordTerminator.equals("") || commandWordTerminator.equals(";")) {
return commandWordTerminator; // EOL or ; reached before subcommand
}
}
return null;
} | java | public static String parseShowStatementSubcommand(String statement)
{
Matcher matcher = ShowToken.matcher(statement);
if (matcher.matches()) {
String commandWordTerminator = matcher.group(1);
if (OneWhitespace.matcher(commandWordTerminator).matches()) {
String trailings = matcher.group(3) + ";" + matcher.group(4);
// In a valid command, both "trailings" groups should be empty.
if (trailings.equals(";")) {
// Return the subcommand keyword -- possibly a valid one.
return matcher.group(2);
}
// For an invalid form of the command,
// return an approximation of the garbage input.
return matcher.group(2) + " " + trailings;
}
if (commandWordTerminator.equals("") || commandWordTerminator.equals(";")) {
return commandWordTerminator; // EOL or ; reached before subcommand
}
}
return null;
} | [
"public",
"static",
"String",
"parseShowStatementSubcommand",
"(",
"String",
"statement",
")",
"{",
"Matcher",
"matcher",
"=",
"ShowToken",
".",
"matcher",
"(",
"statement",
")",
";",
"if",
"(",
"matcher",
".",
"matches",
"(",
")",
")",
"{",
"String",
"comma... | Parse a SHOW or LIST statement for sqlcmd.
@param statement statement to parse
@return String containing captured argument(s) possibly invalid,
or null if a show/list statement wasn't recognized | [
"Parse",
"a",
"SHOW",
"or",
"LIST",
"statement",
"for",
"sqlcmd",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLParser.java#L1507-L1528 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLParser.java | SQLParser.parseHelpStatement | public static String parseHelpStatement(String statement)
{
Matcher matcher = HelpToken.matcher(statement);
if (matcher.matches()) {
String commandWordTerminator = matcher.group(1);
if (OneWhitespace.matcher(commandWordTerminator).matches()) {
String trailings = matcher.group(3) + ";" + matcher.group(4);
// In a valid command, both "trailings" groups should be empty.
if (trailings.equals(";")) {
// Return the subcommand keyword -- possibly a valid one.
return matcher.group(2);
}
// For an invalid form of the command,
// return an approximation of the garbage input.
return matcher.group(2) + " " + trailings;
}
if (commandWordTerminator.equals("") || commandWordTerminator.equals(";")) {
return ""; // EOL or ; reached before subcommand
}
return matcher.group(1).trim();
}
return null;
} | java | public static String parseHelpStatement(String statement)
{
Matcher matcher = HelpToken.matcher(statement);
if (matcher.matches()) {
String commandWordTerminator = matcher.group(1);
if (OneWhitespace.matcher(commandWordTerminator).matches()) {
String trailings = matcher.group(3) + ";" + matcher.group(4);
// In a valid command, both "trailings" groups should be empty.
if (trailings.equals(";")) {
// Return the subcommand keyword -- possibly a valid one.
return matcher.group(2);
}
// For an invalid form of the command,
// return an approximation of the garbage input.
return matcher.group(2) + " " + trailings;
}
if (commandWordTerminator.equals("") || commandWordTerminator.equals(";")) {
return ""; // EOL or ; reached before subcommand
}
return matcher.group(1).trim();
}
return null;
} | [
"public",
"static",
"String",
"parseHelpStatement",
"(",
"String",
"statement",
")",
"{",
"Matcher",
"matcher",
"=",
"HelpToken",
".",
"matcher",
"(",
"statement",
")",
";",
"if",
"(",
"matcher",
".",
"matches",
"(",
")",
")",
"{",
"String",
"commandWordTerm... | Parse HELP statement for sqlcmd.
The sub-command will be "" if the user just typed HELP.
@param statement statement to parse
@return Sub-command or NULL if statement wasn't recognized | [
"Parse",
"HELP",
"statement",
"for",
"sqlcmd",
".",
"The",
"sub",
"-",
"command",
"will",
"be",
"if",
"the",
"user",
"just",
"typed",
"HELP",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLParser.java#L1536-L1558 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLParser.java | SQLParser.getDigitsFromHexLiteral | public static String getDigitsFromHexLiteral(String paramString) {
Matcher matcher = SingleQuotedHexLiteral.matcher(paramString);
if (matcher.matches()) {
return matcher.group(1);
}
return null;
} | java | public static String getDigitsFromHexLiteral(String paramString) {
Matcher matcher = SingleQuotedHexLiteral.matcher(paramString);
if (matcher.matches()) {
return matcher.group(1);
}
return null;
} | [
"public",
"static",
"String",
"getDigitsFromHexLiteral",
"(",
"String",
"paramString",
")",
"{",
"Matcher",
"matcher",
"=",
"SingleQuotedHexLiteral",
".",
"matcher",
"(",
"paramString",
")",
";",
"if",
"(",
"matcher",
".",
"matches",
"(",
")",
")",
"{",
"retur... | Given a parameter string, if it's of the form x'0123456789ABCDEF',
return a string containing just the digits. Otherwise, return null. | [
"Given",
"a",
"parameter",
"string",
"if",
"it",
"s",
"of",
"the",
"form",
"x",
"0123456789ABCDEF",
"return",
"a",
"string",
"containing",
"just",
"the",
"digits",
".",
"Otherwise",
"return",
"null",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLParser.java#L1612-L1618 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLParser.java | SQLParser.hexDigitsToLong | public static long hexDigitsToLong(String hexDigits) throws SQLParser.Exception {
// BigInteger.longValue() will truncate to the lowest 64 bits,
// so we need to explicitly check if there's too many digits.
if (hexDigits.length() > 16) {
throw new SQLParser.Exception("Too many hexadecimal digits for BIGINT value");
}
if (hexDigits.length() == 0) {
throw new SQLParser.Exception("Zero hexadecimal digits is invalid for BIGINT value");
}
// The method
// Long.parseLong(<digits>, <radix>);
// Doesn't quite do what we want---it expects a '-' to
// indicate negative values, and doesn't want the sign bit set
// in the hex digits.
//
// Once we support Java 1.8, we can use Long.parseUnsignedLong(<digits>, 16)
// instead.
long val = new BigInteger(hexDigits, 16).longValue();
return val;
} | java | public static long hexDigitsToLong(String hexDigits) throws SQLParser.Exception {
// BigInteger.longValue() will truncate to the lowest 64 bits,
// so we need to explicitly check if there's too many digits.
if (hexDigits.length() > 16) {
throw new SQLParser.Exception("Too many hexadecimal digits for BIGINT value");
}
if (hexDigits.length() == 0) {
throw new SQLParser.Exception("Zero hexadecimal digits is invalid for BIGINT value");
}
// The method
// Long.parseLong(<digits>, <radix>);
// Doesn't quite do what we want---it expects a '-' to
// indicate negative values, and doesn't want the sign bit set
// in the hex digits.
//
// Once we support Java 1.8, we can use Long.parseUnsignedLong(<digits>, 16)
// instead.
long val = new BigInteger(hexDigits, 16).longValue();
return val;
} | [
"public",
"static",
"long",
"hexDigitsToLong",
"(",
"String",
"hexDigits",
")",
"throws",
"SQLParser",
".",
"Exception",
"{",
"// BigInteger.longValue() will truncate to the lowest 64 bits,",
"// so we need to explicitly check if there's too many digits.",
"if",
"(",
"hexDigits",
... | Given a string of hex digits, produce a long value, assuming
a 2's complement representation. | [
"Given",
"a",
"string",
"of",
"hex",
"digits",
"produce",
"a",
"long",
"value",
"assuming",
"a",
"2",
"s",
"complement",
"representation",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLParser.java#L1624-L1647 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLParser.java | SQLParser.parseExecuteCall | public static ExecuteCallResults parseExecuteCall(
String statement,
Map<String,Map<Integer, List<String>>> procedures) throws SQLParser.Exception
{
assert(procedures != null);
return parseExecuteCallInternal(statement, procedures);
} | java | public static ExecuteCallResults parseExecuteCall(
String statement,
Map<String,Map<Integer, List<String>>> procedures) throws SQLParser.Exception
{
assert(procedures != null);
return parseExecuteCallInternal(statement, procedures);
} | [
"public",
"static",
"ExecuteCallResults",
"parseExecuteCall",
"(",
"String",
"statement",
",",
"Map",
"<",
"String",
",",
"Map",
"<",
"Integer",
",",
"List",
"<",
"String",
">",
">",
">",
"procedures",
")",
"throws",
"SQLParser",
".",
"Exception",
"{",
"asse... | Parse EXECUTE procedure call.
@param statement statement to parse
@param procedures maps procedures to parameter signature maps
@return results object or NULL if statement wasn't recognized
@throws SQLParser.Exception | [
"Parse",
"EXECUTE",
"procedure",
"call",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLParser.java#L1792-L1798 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLParser.java | SQLParser.parseExecuteCallInternal | private static ExecuteCallResults parseExecuteCallInternal(
String statement, Map<String,Map<Integer, List<String>>> procedures
) throws SQLParser.Exception
{
Matcher matcher = ExecuteCallPreamble.matcher(statement);
if ( ! matcher.lookingAt()) {
return null;
}
String commandWordTerminator = matcher.group(1);
if (OneWhitespace.matcher(commandWordTerminator).matches() ||
// Might as well accept a comma delimiter anywhere in the exec command,
// even near the start
commandWordTerminator.equals(",")) {
ExecuteCallResults results = new ExecuteCallResults();
String rawParams = statement.substring(matcher.end());
results.params = parseExecParameters(rawParams);
results.procedure = results.params.remove(0);
// TestSqlCmdInterface passes procedures==null because it
// doesn't need/want the param types.
if (procedures == null) {
results.paramTypes = null;
return results;
}
Map<Integer, List<String>> signature = procedures.get(results.procedure);
if (signature == null) {
throw new SQLParser.Exception("Undefined procedure: %s", results.procedure);
}
results.paramTypes = signature.get(results.params.size());
if (results.paramTypes == null || results.params.size() != results.paramTypes.size()) {
String expectedSizes = "";
for (Integer expectedSize : signature.keySet()) {
expectedSizes += expectedSize + ", ";
}
throw new SQLParser.Exception(
"Invalid parameter count for procedure: %s (expected: %s received: %d)",
results.procedure, expectedSizes, results.params.size());
}
return results;
}
if (commandWordTerminator.equals(";")) {
// EOL or ; reached before subcommand
throw new SQLParser.Exception(
"Incomplete EXECUTE command. EXECUTE requires a procedure name argument.");
}
throw new SQLParser.Exception(
"Invalid EXECUTE command. unexpected input: '" + commandWordTerminator + "'.");
} | java | private static ExecuteCallResults parseExecuteCallInternal(
String statement, Map<String,Map<Integer, List<String>>> procedures
) throws SQLParser.Exception
{
Matcher matcher = ExecuteCallPreamble.matcher(statement);
if ( ! matcher.lookingAt()) {
return null;
}
String commandWordTerminator = matcher.group(1);
if (OneWhitespace.matcher(commandWordTerminator).matches() ||
// Might as well accept a comma delimiter anywhere in the exec command,
// even near the start
commandWordTerminator.equals(",")) {
ExecuteCallResults results = new ExecuteCallResults();
String rawParams = statement.substring(matcher.end());
results.params = parseExecParameters(rawParams);
results.procedure = results.params.remove(0);
// TestSqlCmdInterface passes procedures==null because it
// doesn't need/want the param types.
if (procedures == null) {
results.paramTypes = null;
return results;
}
Map<Integer, List<String>> signature = procedures.get(results.procedure);
if (signature == null) {
throw new SQLParser.Exception("Undefined procedure: %s", results.procedure);
}
results.paramTypes = signature.get(results.params.size());
if (results.paramTypes == null || results.params.size() != results.paramTypes.size()) {
String expectedSizes = "";
for (Integer expectedSize : signature.keySet()) {
expectedSizes += expectedSize + ", ";
}
throw new SQLParser.Exception(
"Invalid parameter count for procedure: %s (expected: %s received: %d)",
results.procedure, expectedSizes, results.params.size());
}
return results;
}
if (commandWordTerminator.equals(";")) {
// EOL or ; reached before subcommand
throw new SQLParser.Exception(
"Incomplete EXECUTE command. EXECUTE requires a procedure name argument.");
}
throw new SQLParser.Exception(
"Invalid EXECUTE command. unexpected input: '" + commandWordTerminator + "'.");
} | [
"private",
"static",
"ExecuteCallResults",
"parseExecuteCallInternal",
"(",
"String",
"statement",
",",
"Map",
"<",
"String",
",",
"Map",
"<",
"Integer",
",",
"List",
"<",
"String",
">",
">",
">",
"procedures",
")",
"throws",
"SQLParser",
".",
"Exception",
"{"... | Private implementation of parse EXECUTE procedure call.
Also supports short-circuiting procedure lookup for testing.
@param statement statement to parse
@param procedures maps procedures to parameter signature maps
@return results object or NULL if statement wasn't recognized
@throws SQLParser.Exception | [
"Private",
"implementation",
"of",
"parse",
"EXECUTE",
"procedure",
"call",
".",
"Also",
"supports",
"short",
"-",
"circuiting",
"procedure",
"lookup",
"for",
"testing",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLParser.java#L1822-L1869 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLParser.java | SQLParser.appearsToBeValidDDLBatch | public static boolean appearsToBeValidDDLBatch(String batch) {
BufferedReader reader = new BufferedReader(new StringReader(batch));
String line;
try {
while ((line = reader.readLine()) != null) {
if (isWholeLineComment(line)) {
continue;
}
line = line.trim();
if (line.equals(""))
continue;
// we have a non-blank line that contains more than just a comment.
return queryIsDDL(line);
}
}
catch (IOException e) {
// This should never happen for a StringReader
assert(false);
}
// trivial empty batch: no lines are non-blank or non-comments
return true;
} | java | public static boolean appearsToBeValidDDLBatch(String batch) {
BufferedReader reader = new BufferedReader(new StringReader(batch));
String line;
try {
while ((line = reader.readLine()) != null) {
if (isWholeLineComment(line)) {
continue;
}
line = line.trim();
if (line.equals(""))
continue;
// we have a non-blank line that contains more than just a comment.
return queryIsDDL(line);
}
}
catch (IOException e) {
// This should never happen for a StringReader
assert(false);
}
// trivial empty batch: no lines are non-blank or non-comments
return true;
} | [
"public",
"static",
"boolean",
"appearsToBeValidDDLBatch",
"(",
"String",
"batch",
")",
"{",
"BufferedReader",
"reader",
"=",
"new",
"BufferedReader",
"(",
"new",
"StringReader",
"(",
"batch",
")",
")",
";",
"String",
"line",
";",
"try",
"{",
"while",
"(",
"... | Make sure that the batch starts with an appropriate DDL verb. We do not
look further than the first token of the first non-comment and non-whitespace line.
Empty batches are considered to be trivially valid.
@param batch A SQL string containing multiple statements separated by semicolons
@return true if the first keyword of the first statement is a DDL verb
like CREATE, ALTER, DROP, PARTITION, DR, SET or EXPORT,
or if the batch is empty.
See the official list of DDL verbs in the "// Supported verbs" section of
the static initializer for SQLLexer.VERB_TOKENS) | [
"Make",
"sure",
"that",
"the",
"batch",
"starts",
"with",
"an",
"appropriate",
"DDL",
"verb",
".",
"We",
"do",
"not",
"look",
"further",
"than",
"the",
"first",
"token",
"of",
"the",
"first",
"non",
"-",
"comment",
"and",
"non",
"-",
"whitespace",
"line"... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLParser.java#L2012-L2036 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLParser.java | SQLParser.parseEchoStatement | public static String parseEchoStatement(String statement)
{
Matcher matcher = EchoToken.matcher(statement);
if (matcher.matches()) {
String commandWordTerminator = matcher.group(1);
if (OneWhitespace.matcher(commandWordTerminator).matches()) {
return matcher.group(2);
}
return "";
}
return null;
} | java | public static String parseEchoStatement(String statement)
{
Matcher matcher = EchoToken.matcher(statement);
if (matcher.matches()) {
String commandWordTerminator = matcher.group(1);
if (OneWhitespace.matcher(commandWordTerminator).matches()) {
return matcher.group(2);
}
return "";
}
return null;
} | [
"public",
"static",
"String",
"parseEchoStatement",
"(",
"String",
"statement",
")",
"{",
"Matcher",
"matcher",
"=",
"EchoToken",
".",
"matcher",
"(",
"statement",
")",
";",
"if",
"(",
"matcher",
".",
"matches",
"(",
")",
")",
"{",
"String",
"commandWordTerm... | Parse ECHO statement for sqlcmd.
The result will be "" if the user just typed ECHO.
@param statement statement to parse
@return Argument text or NULL if statement wasn't recognized | [
"Parse",
"ECHO",
"statement",
"for",
"sqlcmd",
".",
"The",
"result",
"will",
"be",
"if",
"the",
"user",
"just",
"typed",
"ECHO",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLParser.java#L2044-L2055 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLParser.java | SQLParser.parseEchoErrorStatement | public static String parseEchoErrorStatement(String statement) {
Matcher matcher = EchoErrorToken.matcher(statement);
if (matcher.matches()) {
String commandWordTerminator = matcher.group(1);
if (OneWhitespace.matcher(commandWordTerminator).matches()) {
return matcher.group(2);
}
return "";
}
return null;
} | java | public static String parseEchoErrorStatement(String statement) {
Matcher matcher = EchoErrorToken.matcher(statement);
if (matcher.matches()) {
String commandWordTerminator = matcher.group(1);
if (OneWhitespace.matcher(commandWordTerminator).matches()) {
return matcher.group(2);
}
return "";
}
return null;
} | [
"public",
"static",
"String",
"parseEchoErrorStatement",
"(",
"String",
"statement",
")",
"{",
"Matcher",
"matcher",
"=",
"EchoErrorToken",
".",
"matcher",
"(",
"statement",
")",
";",
"if",
"(",
"matcher",
".",
"matches",
"(",
")",
")",
"{",
"String",
"comma... | Parse ECHOERROR statement for sqlcmd.
The result will be "" if the user just typed ECHOERROR.
@param statement statement to parse
@return Argument text or NULL if statement wasn't recognized | [
"Parse",
"ECHOERROR",
"statement",
"for",
"sqlcmd",
".",
"The",
"result",
"will",
"be",
"if",
"the",
"user",
"just",
"typed",
"ECHOERROR",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLParser.java#L2063-L2073 | train |
VoltDB/voltdb | src/frontend/org/voltdb/parser/SQLParser.java | SQLParser.parseDescribeStatement | public static String parseDescribeStatement(String statement) {
Matcher matcher = DescribeToken.matcher(statement);
if (matcher.matches()) {
String commandWordTerminator = matcher.group(1);
if (OneWhitespace.matcher(commandWordTerminator).matches()) {
String trailings = matcher.group(3) + ";" + matcher.group(4);
// In a valid command, both "trailings" groups should be empty.
if (trailings.equals(";")) {
// Return the subcommand keyword -- possibly a valid one.
return matcher.group(2);
}
// For an invalid form of the command,
// return an approximation of the garbage input.
return matcher.group(2) + " " + trailings;
}
if (commandWordTerminator.equals("") || commandWordTerminator.equals(";")) {
return commandWordTerminator; // EOL or ; reached before subcommand
}
}
return null;
} | java | public static String parseDescribeStatement(String statement) {
Matcher matcher = DescribeToken.matcher(statement);
if (matcher.matches()) {
String commandWordTerminator = matcher.group(1);
if (OneWhitespace.matcher(commandWordTerminator).matches()) {
String trailings = matcher.group(3) + ";" + matcher.group(4);
// In a valid command, both "trailings" groups should be empty.
if (trailings.equals(";")) {
// Return the subcommand keyword -- possibly a valid one.
return matcher.group(2);
}
// For an invalid form of the command,
// return an approximation of the garbage input.
return matcher.group(2) + " " + trailings;
}
if (commandWordTerminator.equals("") || commandWordTerminator.equals(";")) {
return commandWordTerminator; // EOL or ; reached before subcommand
}
}
return null;
} | [
"public",
"static",
"String",
"parseDescribeStatement",
"(",
"String",
"statement",
")",
"{",
"Matcher",
"matcher",
"=",
"DescribeToken",
".",
"matcher",
"(",
"statement",
")",
";",
"if",
"(",
"matcher",
".",
"matches",
"(",
")",
")",
"{",
"String",
"command... | Parse DESCRIBE statement for sqlcmd.
The result will be "" if the user just typed DESCRIBE or DESC.
@param statement statement to parse
@return String containing possible table name | [
"Parse",
"DESCRIBE",
"statement",
"for",
"sqlcmd",
".",
"The",
"result",
"will",
"be",
"if",
"the",
"user",
"just",
"typed",
"DESCRIBE",
"or",
"DESC",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/parser/SQLParser.java#L2081-L2101 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/QueryExpression.java | QueryExpression.resolveColumnRefernecesInUnionOrderBy | void resolveColumnRefernecesInUnionOrderBy() {
int orderCount = sortAndSlice.getOrderLength();
if (orderCount == 0) {
return;
}
String[] unionColumnNames = getColumnNames();
for (int i = 0; i < orderCount; i++) {
Expression sort = (Expression) sortAndSlice.exprList.get(i);
Expression e = sort.getLeftNode();
if (e.getType() == OpTypes.VALUE) {
if (e.getDataType().typeCode == Types.SQL_INTEGER) {
int index = ((Integer) e.getValue(null)).intValue();
if (0 < index && index <= unionColumnNames.length) {
sort.getLeftNode().queryTableColumnIndex = index - 1;
continue;
}
}
} else if (e.getType() == OpTypes.COLUMN) {
int index = ArrayUtil.find(unionColumnNames,
e.getColumnName());
if (index >= 0) {
sort.getLeftNode().queryTableColumnIndex = index;
continue;
}
}
throw Error.error(ErrorCode.X_42576);
}
sortAndSlice.prepare(null);
} | java | void resolveColumnRefernecesInUnionOrderBy() {
int orderCount = sortAndSlice.getOrderLength();
if (orderCount == 0) {
return;
}
String[] unionColumnNames = getColumnNames();
for (int i = 0; i < orderCount; i++) {
Expression sort = (Expression) sortAndSlice.exprList.get(i);
Expression e = sort.getLeftNode();
if (e.getType() == OpTypes.VALUE) {
if (e.getDataType().typeCode == Types.SQL_INTEGER) {
int index = ((Integer) e.getValue(null)).intValue();
if (0 < index && index <= unionColumnNames.length) {
sort.getLeftNode().queryTableColumnIndex = index - 1;
continue;
}
}
} else if (e.getType() == OpTypes.COLUMN) {
int index = ArrayUtil.find(unionColumnNames,
e.getColumnName());
if (index >= 0) {
sort.getLeftNode().queryTableColumnIndex = index;
continue;
}
}
throw Error.error(ErrorCode.X_42576);
}
sortAndSlice.prepare(null);
} | [
"void",
"resolveColumnRefernecesInUnionOrderBy",
"(",
")",
"{",
"int",
"orderCount",
"=",
"sortAndSlice",
".",
"getOrderLength",
"(",
")",
";",
"if",
"(",
"orderCount",
"==",
"0",
")",
"{",
"return",
";",
"}",
"String",
"[",
"]",
"unionColumnNames",
"=",
"ge... | Only simple column reference or column position allowed | [
"Only",
"simple",
"column",
"reference",
"or",
"column",
"position",
"allowed"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/QueryExpression.java#L331-L370 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/QueryExpression.java | QueryExpression.setTableColumnNames | public void setTableColumnNames(HashMappedList list) {
if (resultTable != null) {
((TableDerived) resultTable).columnList = list;
return;
}
leftQueryExpression.setTableColumnNames(list);
} | java | public void setTableColumnNames(HashMappedList list) {
if (resultTable != null) {
((TableDerived) resultTable).columnList = list;
return;
}
leftQueryExpression.setTableColumnNames(list);
} | [
"public",
"void",
"setTableColumnNames",
"(",
"HashMappedList",
"list",
")",
"{",
"if",
"(",
"resultTable",
"!=",
"null",
")",
"{",
"(",
"(",
"TableDerived",
")",
"resultTable",
")",
".",
"columnList",
"=",
"list",
";",
"return",
";",
"}",
"leftQueryExpressi... | Used in views after full type resolution | [
"Used",
"in",
"views",
"after",
"full",
"type",
"resolution"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/QueryExpression.java#L670-L679 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/QueryExpression.java | QueryExpression.setAsTopLevel | public void setAsTopLevel() {
if (compileContext.getSequences().length > 0) {
throw Error.error(ErrorCode.X_42598);
}
isTopLevel = true;
setReturningResultSet();
} | java | public void setAsTopLevel() {
if (compileContext.getSequences().length > 0) {
throw Error.error(ErrorCode.X_42598);
}
isTopLevel = true;
setReturningResultSet();
} | [
"public",
"void",
"setAsTopLevel",
"(",
")",
"{",
"if",
"(",
"compileContext",
".",
"getSequences",
"(",
")",
".",
"length",
">",
"0",
")",
"{",
"throw",
"Error",
".",
"error",
"(",
"ErrorCode",
".",
"X_42598",
")",
";",
"}",
"isTopLevel",
"=",
"true",... | Not for views. Only used on root node. | [
"Not",
"for",
"views",
".",
"Only",
"used",
"on",
"root",
"node",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/QueryExpression.java#L733-L742 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/QueryExpression.java | QueryExpression.setReturningResultSet | void setReturningResultSet() {
if (unionCorresponding) {
persistenceScope = TableBase.SCOPE_SESSION;
columnMode = TableBase.COLUMNS_UNREFERENCED;
return;
}
leftQueryExpression.setReturningResultSet();
} | java | void setReturningResultSet() {
if (unionCorresponding) {
persistenceScope = TableBase.SCOPE_SESSION;
columnMode = TableBase.COLUMNS_UNREFERENCED;
return;
}
leftQueryExpression.setReturningResultSet();
} | [
"void",
"setReturningResultSet",
"(",
")",
"{",
"if",
"(",
"unionCorresponding",
")",
"{",
"persistenceScope",
"=",
"TableBase",
".",
"SCOPE_SESSION",
";",
"columnMode",
"=",
"TableBase",
".",
"COLUMNS_UNREFERENCED",
";",
"return",
";",
"}",
"leftQueryExpression",
... | Sets the scope to SESSION for the QueryExpression object that creates
the table | [
"Sets",
"the",
"scope",
"to",
"SESSION",
"for",
"the",
"QueryExpression",
"object",
"that",
"creates",
"the",
"table"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/QueryExpression.java#L748-L758 | train |
VoltDB/voltdb | examples/geospatial/client/geospatial/AdBrokerBenchmark.java | AdBrokerBenchmark.schedulePeriodicStats | public void schedulePeriodicStats() {
Runnable statsPrinter = new Runnable() {
@Override
public void run() { printStatistics(); }
};
m_scheduler.scheduleWithFixedDelay(statsPrinter,
m_config.displayinterval,
m_config.displayinterval,
TimeUnit.SECONDS);
} | java | public void schedulePeriodicStats() {
Runnable statsPrinter = new Runnable() {
@Override
public void run() { printStatistics(); }
};
m_scheduler.scheduleWithFixedDelay(statsPrinter,
m_config.displayinterval,
m_config.displayinterval,
TimeUnit.SECONDS);
} | [
"public",
"void",
"schedulePeriodicStats",
"(",
")",
"{",
"Runnable",
"statsPrinter",
"=",
"new",
"Runnable",
"(",
")",
"{",
"@",
"Override",
"public",
"void",
"run",
"(",
")",
"{",
"printStatistics",
"(",
")",
";",
"}",
"}",
";",
"m_scheduler",
".",
"sc... | Add a task to the scheduler to print statistics to the console
at regular intervals. | [
"Add",
"a",
"task",
"to",
"the",
"scheduler",
"to",
"print",
"statistics",
"to",
"the",
"console",
"at",
"regular",
"intervals",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/examples/geospatial/client/geospatial/AdBrokerBenchmark.java#L248-L257 | train |
VoltDB/voltdb | examples/geospatial/client/geospatial/AdBrokerBenchmark.java | AdBrokerBenchmark.printResults | public synchronized void printResults() throws Exception {
ClientStats stats = m_fullStatsContext.fetch().getStats();
System.out.print(HORIZONTAL_RULE);
System.out.println(" Client Workload Statistics");
System.out.println(HORIZONTAL_RULE);
System.out.printf("Average throughput: %,9d txns/sec\n", stats.getTxnThroughput());
if(m_config.latencyreport) {
System.out.printf("Average latency: %,9.2f ms\n", stats.getAverageLatency());
System.out.printf("10th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.1));
System.out.printf("25th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.25));
System.out.printf("50th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.5));
System.out.printf("75th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.75));
System.out.printf("90th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.9));
System.out.printf("95th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.95));
System.out.printf("99th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.99));
System.out.printf("99.5th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.995));
System.out.printf("99.9th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.999));
System.out.print("\n" + HORIZONTAL_RULE);
System.out.println(" System Server Statistics");
System.out.println(HORIZONTAL_RULE);
System.out.printf("Reported Internal Avg Latency: %,9.2f ms\n", stats.getAverageInternalLatency());
System.out.print("\n" + HORIZONTAL_RULE);
System.out.println(" Latency Histogram");
System.out.println(HORIZONTAL_RULE);
System.out.println(stats.latencyHistoReport());
}
// 4. Write stats to file if requested
m_client.writeSummaryCSV(stats, m_config.statsfile);
} | java | public synchronized void printResults() throws Exception {
ClientStats stats = m_fullStatsContext.fetch().getStats();
System.out.print(HORIZONTAL_RULE);
System.out.println(" Client Workload Statistics");
System.out.println(HORIZONTAL_RULE);
System.out.printf("Average throughput: %,9d txns/sec\n", stats.getTxnThroughput());
if(m_config.latencyreport) {
System.out.printf("Average latency: %,9.2f ms\n", stats.getAverageLatency());
System.out.printf("10th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.1));
System.out.printf("25th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.25));
System.out.printf("50th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.5));
System.out.printf("75th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.75));
System.out.printf("90th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.9));
System.out.printf("95th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.95));
System.out.printf("99th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.99));
System.out.printf("99.5th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.995));
System.out.printf("99.9th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.999));
System.out.print("\n" + HORIZONTAL_RULE);
System.out.println(" System Server Statistics");
System.out.println(HORIZONTAL_RULE);
System.out.printf("Reported Internal Avg Latency: %,9.2f ms\n", stats.getAverageInternalLatency());
System.out.print("\n" + HORIZONTAL_RULE);
System.out.println(" Latency Histogram");
System.out.println(HORIZONTAL_RULE);
System.out.println(stats.latencyHistoReport());
}
// 4. Write stats to file if requested
m_client.writeSummaryCSV(stats, m_config.statsfile);
} | [
"public",
"synchronized",
"void",
"printResults",
"(",
")",
"throws",
"Exception",
"{",
"ClientStats",
"stats",
"=",
"m_fullStatsContext",
".",
"fetch",
"(",
")",
".",
"getStats",
"(",
")",
";",
"System",
".",
"out",
".",
"print",
"(",
"HORIZONTAL_RULE",
")"... | Prints some summary statistics about performance.
@throws Exception if anything unexpected happens. | [
"Prints",
"some",
"summary",
"statistics",
"about",
"performance",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/examples/geospatial/client/geospatial/AdBrokerBenchmark.java#L315-L348 | train |
VoltDB/voltdb | examples/geospatial/client/geospatial/AdBrokerBenchmark.java | AdBrokerBenchmark.shutdown | private void shutdown() {
// Stop the stats printer, the bid generator and the nibble deleter.
m_scheduler.shutdown();
try {
m_scheduler.awaitTermination(60, TimeUnit.SECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
// block until all outstanding txns return
m_client.drain();
// close down the client connections
m_client.close();
}
catch (IOException | InterruptedException e) {
e.printStackTrace();
}
} | java | private void shutdown() {
// Stop the stats printer, the bid generator and the nibble deleter.
m_scheduler.shutdown();
try {
m_scheduler.awaitTermination(60, TimeUnit.SECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
// block until all outstanding txns return
m_client.drain();
// close down the client connections
m_client.close();
}
catch (IOException | InterruptedException e) {
e.printStackTrace();
}
} | [
"private",
"void",
"shutdown",
"(",
")",
"{",
"// Stop the stats printer, the bid generator and the nibble deleter.",
"m_scheduler",
".",
"shutdown",
"(",
")",
";",
"try",
"{",
"m_scheduler",
".",
"awaitTermination",
"(",
"60",
",",
"TimeUnit",
".",
"SECONDS",
")",
... | Perform various tasks to end the demo cleanly. | [
"Perform",
"various",
"tasks",
"to",
"end",
"the",
"demo",
"cleanly",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/examples/geospatial/client/geospatial/AdBrokerBenchmark.java#L353-L373 | train |
VoltDB/voltdb | examples/geospatial/client/geospatial/AdBrokerBenchmark.java | AdBrokerBenchmark.requestAd | private void requestAd() {
long deviceId = Math.abs(m_rand.nextLong()) % AdBrokerBenchmark.NUM_DEVICES;
GeographyPointValue point = getRandomPoint();
try {
m_client.callProcedure(new NullCallback(), "GetHighestBidForLocation", deviceId, point);
} catch (IOException e) {
e.printStackTrace();
}
} | java | private void requestAd() {
long deviceId = Math.abs(m_rand.nextLong()) % AdBrokerBenchmark.NUM_DEVICES;
GeographyPointValue point = getRandomPoint();
try {
m_client.callProcedure(new NullCallback(), "GetHighestBidForLocation", deviceId, point);
} catch (IOException e) {
e.printStackTrace();
}
} | [
"private",
"void",
"requestAd",
"(",
")",
"{",
"long",
"deviceId",
"=",
"Math",
".",
"abs",
"(",
"m_rand",
".",
"nextLong",
"(",
")",
")",
"%",
"AdBrokerBenchmark",
".",
"NUM_DEVICES",
";",
"GeographyPointValue",
"point",
"=",
"getRandomPoint",
"(",
")",
"... | Invoke the stored procedure GetHighestBidForLocation, which, given a random
point, returns the id of the bid that has the highest dollar amount. | [
"Invoke",
"the",
"stored",
"procedure",
"GetHighestBidForLocation",
"which",
"given",
"a",
"random",
"point",
"returns",
"the",
"id",
"of",
"the",
"bid",
"that",
"has",
"the",
"highest",
"dollar",
"amount",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/examples/geospatial/client/geospatial/AdBrokerBenchmark.java#L395-L404 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/parseinfo/StmtSubqueryScan.java | StmtSubqueryScan.promoteSinglePartitionInfo | public void promoteSinglePartitionInfo(
HashMap<AbstractExpression, Set<AbstractExpression>> valueEquivalence,
Set< Set<AbstractExpression> > eqSets) {
assert(getScanPartitioning() != null);
if (getScanPartitioning().getCountOfPartitionedTables() == 0 ||
getScanPartitioning().requiresTwoFragments()) {
return;
}
// This subquery is a single partitioned query on partitioned tables
// promoting the single partition expression up to its parent level.
AbstractExpression spExpr = getScanPartitioning().singlePartitioningExpression();
for (SchemaColumn col: m_partitioningColumns) {
AbstractExpression tveKey = col.getExpression();
assert(tveKey instanceof TupleValueExpression);
Set<AbstractExpression> values = null;
if (valueEquivalence.containsKey(tveKey)) {
values = valueEquivalence.get(tveKey);
}
else if (valueEquivalence.containsKey(spExpr)) {
values = valueEquivalence.get(spExpr);
}
else {
for (SchemaColumn otherCol: m_partitioningColumns) {
if (col != otherCol &&
valueEquivalence.containsKey(otherCol.getExpression())) {
values = valueEquivalence.get(otherCol.getExpression());
break;
}
}
if (values == null) {
values = new HashSet<>();
}
}
updateEqualSets(values, valueEquivalence, eqSets, tveKey, spExpr);
}
} | java | public void promoteSinglePartitionInfo(
HashMap<AbstractExpression, Set<AbstractExpression>> valueEquivalence,
Set< Set<AbstractExpression> > eqSets) {
assert(getScanPartitioning() != null);
if (getScanPartitioning().getCountOfPartitionedTables() == 0 ||
getScanPartitioning().requiresTwoFragments()) {
return;
}
// This subquery is a single partitioned query on partitioned tables
// promoting the single partition expression up to its parent level.
AbstractExpression spExpr = getScanPartitioning().singlePartitioningExpression();
for (SchemaColumn col: m_partitioningColumns) {
AbstractExpression tveKey = col.getExpression();
assert(tveKey instanceof TupleValueExpression);
Set<AbstractExpression> values = null;
if (valueEquivalence.containsKey(tveKey)) {
values = valueEquivalence.get(tveKey);
}
else if (valueEquivalence.containsKey(spExpr)) {
values = valueEquivalence.get(spExpr);
}
else {
for (SchemaColumn otherCol: m_partitioningColumns) {
if (col != otherCol &&
valueEquivalence.containsKey(otherCol.getExpression())) {
values = valueEquivalence.get(otherCol.getExpression());
break;
}
}
if (values == null) {
values = new HashSet<>();
}
}
updateEqualSets(values, valueEquivalence, eqSets, tveKey, spExpr);
}
} | [
"public",
"void",
"promoteSinglePartitionInfo",
"(",
"HashMap",
"<",
"AbstractExpression",
",",
"Set",
"<",
"AbstractExpression",
">",
">",
"valueEquivalence",
",",
"Set",
"<",
"Set",
"<",
"AbstractExpression",
">",
">",
"eqSets",
")",
"{",
"assert",
"(",
"getSc... | upgrade single partitioning expression to parent level
add the info to equality sets and input value equivalence
@param valueEquivalence
@param eqSets | [
"upgrade",
"single",
"partitioning",
"expression",
"to",
"parent",
"level",
"add",
"the",
"info",
"to",
"equality",
"sets",
"and",
"input",
"value",
"equivalence"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/parseinfo/StmtSubqueryScan.java#L95-L132 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/parseinfo/StmtSubqueryScan.java | StmtSubqueryScan.updateEqualSets | private void updateEqualSets(Set<AbstractExpression> values,
HashMap<AbstractExpression, Set<AbstractExpression>> valueEquivalence,
Set< Set<AbstractExpression> > eqSets,
AbstractExpression tveKey, AbstractExpression spExpr) {
boolean hasLegacyValues = false;
if (eqSets.contains(values)) {
eqSets.remove(values);
hasLegacyValues = true;
}
values.add(spExpr);
values.add(tveKey);
if (hasLegacyValues) {
eqSets.add(values);
}
valueEquivalence.put(spExpr, values);
valueEquivalence.put(tveKey, values);
} | java | private void updateEqualSets(Set<AbstractExpression> values,
HashMap<AbstractExpression, Set<AbstractExpression>> valueEquivalence,
Set< Set<AbstractExpression> > eqSets,
AbstractExpression tveKey, AbstractExpression spExpr) {
boolean hasLegacyValues = false;
if (eqSets.contains(values)) {
eqSets.remove(values);
hasLegacyValues = true;
}
values.add(spExpr);
values.add(tveKey);
if (hasLegacyValues) {
eqSets.add(values);
}
valueEquivalence.put(spExpr, values);
valueEquivalence.put(tveKey, values);
} | [
"private",
"void",
"updateEqualSets",
"(",
"Set",
"<",
"AbstractExpression",
">",
"values",
",",
"HashMap",
"<",
"AbstractExpression",
",",
"Set",
"<",
"AbstractExpression",
">",
">",
"valueEquivalence",
",",
"Set",
"<",
"Set",
"<",
"AbstractExpression",
">",
">... | Because HashSet stored a legacy hashcode for the non-final object. | [
"Because",
"HashSet",
"stored",
"a",
"legacy",
"hashcode",
"for",
"the",
"non",
"-",
"final",
"object",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/parseinfo/StmtSubqueryScan.java#L137-L153 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/parseinfo/StmtSubqueryScan.java | StmtSubqueryScan.getIsReplicated | @Override
public boolean getIsReplicated() {
for (StmtTableScan tableScan : m_subqueryStmt.allScans()) {
if ( ! tableScan.getIsReplicated()) {
return false;
}
}
return true;
} | java | @Override
public boolean getIsReplicated() {
for (StmtTableScan tableScan : m_subqueryStmt.allScans()) {
if ( ! tableScan.getIsReplicated()) {
return false;
}
}
return true;
} | [
"@",
"Override",
"public",
"boolean",
"getIsReplicated",
"(",
")",
"{",
"for",
"(",
"StmtTableScan",
"tableScan",
":",
"m_subqueryStmt",
".",
"allScans",
"(",
")",
")",
"{",
"if",
"(",
"!",
"tableScan",
".",
"getIsReplicated",
"(",
")",
")",
"{",
"return",... | The subquery is replicated if all tables from the FROM clause defining this subquery
are replicated
@return True if the subquery is replicated | [
"The",
"subquery",
"is",
"replicated",
"if",
"all",
"tables",
"from",
"the",
"FROM",
"clause",
"defining",
"this",
"subquery",
"are",
"replicated"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/parseinfo/StmtSubqueryScan.java#L218-L226 | train |
VoltDB/voltdb | src/frontend/org/voltdb/planner/parseinfo/StmtSubqueryScan.java | StmtSubqueryScan.getOutputExpression | public TupleValueExpression getOutputExpression(int index) {
SchemaColumn schemaCol = getSchemaColumn(index);
TupleValueExpression tve = new TupleValueExpression(getTableAlias(), getTableAlias(),
schemaCol.getColumnAlias(), schemaCol.getColumnAlias(), index);
return tve;
} | java | public TupleValueExpression getOutputExpression(int index) {
SchemaColumn schemaCol = getSchemaColumn(index);
TupleValueExpression tve = new TupleValueExpression(getTableAlias(), getTableAlias(),
schemaCol.getColumnAlias(), schemaCol.getColumnAlias(), index);
return tve;
} | [
"public",
"TupleValueExpression",
"getOutputExpression",
"(",
"int",
"index",
")",
"{",
"SchemaColumn",
"schemaCol",
"=",
"getSchemaColumn",
"(",
"index",
")",
";",
"TupleValueExpression",
"tve",
"=",
"new",
"TupleValueExpression",
"(",
"getTableAlias",
"(",
")",
",... | Produce a tuple value expression for a column produced by this subquery | [
"Produce",
"a",
"tuple",
"value",
"expression",
"for",
"a",
"column",
"produced",
"by",
"this",
"subquery"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/planner/parseinfo/StmtSubqueryScan.java#L363-L368 | train |
VoltDB/voltdb | src/frontend/org/voltdb/expressions/ComparisonExpression.java | ComparisonExpression.rangeFilterFromPrefixLike | static private ComparisonExpression rangeFilterFromPrefixLike(AbstractExpression leftExpr, ExpressionType rangeComparator, String comparand) {
ConstantValueExpression cve = new ConstantValueExpression();
cve.setValueType(VoltType.STRING);
cve.setValue(comparand);
cve.setValueSize(comparand.length());
ComparisonExpression rangeFilter = new ComparisonExpression(rangeComparator, leftExpr, cve);
return rangeFilter;
} | java | static private ComparisonExpression rangeFilterFromPrefixLike(AbstractExpression leftExpr, ExpressionType rangeComparator, String comparand) {
ConstantValueExpression cve = new ConstantValueExpression();
cve.setValueType(VoltType.STRING);
cve.setValue(comparand);
cve.setValueSize(comparand.length());
ComparisonExpression rangeFilter = new ComparisonExpression(rangeComparator, leftExpr, cve);
return rangeFilter;
} | [
"static",
"private",
"ComparisonExpression",
"rangeFilterFromPrefixLike",
"(",
"AbstractExpression",
"leftExpr",
",",
"ExpressionType",
"rangeComparator",
",",
"String",
"comparand",
")",
"{",
"ConstantValueExpression",
"cve",
"=",
"new",
"ConstantValueExpression",
"(",
")"... | Construct the upper or lower bound expression that is implied by a prefix LIKE operator, given its required elements.
@param leftExpr - the LIKE operator's (and the result's) lhs expression
@param rangeComparator - a GTE or LT operator to indicate lower or upper bound, respectively,
@param comparand - a string operand value derived from the LIKE operator's rhs pattern
A helper for getGteFilterFromPrefixLike/getLtFilterFromPrefixLike | [
"Construct",
"the",
"upper",
"or",
"lower",
"bound",
"expression",
"that",
"is",
"implied",
"by",
"a",
"prefix",
"LIKE",
"operator",
"given",
"its",
"required",
"elements",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/expressions/ComparisonExpression.java#L144-L151 | train |
VoltDB/voltdb | src/frontend/org/voltdb/plannodes/NodeSchema.java | NodeSchema.resetTableName | public NodeSchema resetTableName(String tbName, String tbAlias) {
m_columns.forEach(sc ->
sc.reset(tbName, tbAlias, sc.getColumnName(), sc.getColumnAlias()));
m_columnsMapHelper.forEach((k, v) ->
k.reset(tbName, tbAlias, k.getColumnName(), k.getColumnAlias()));
return this;
} | java | public NodeSchema resetTableName(String tbName, String tbAlias) {
m_columns.forEach(sc ->
sc.reset(tbName, tbAlias, sc.getColumnName(), sc.getColumnAlias()));
m_columnsMapHelper.forEach((k, v) ->
k.reset(tbName, tbAlias, k.getColumnName(), k.getColumnAlias()));
return this;
} | [
"public",
"NodeSchema",
"resetTableName",
"(",
"String",
"tbName",
",",
"String",
"tbAlias",
")",
"{",
"m_columns",
".",
"forEach",
"(",
"sc",
"->",
"sc",
".",
"reset",
"(",
"tbName",
",",
"tbAlias",
",",
"sc",
".",
"getColumnName",
"(",
")",
",",
"sc",
... | Substitute table name only for all schema columns and map entries | [
"Substitute",
"table",
"name",
"only",
"for",
"all",
"schema",
"columns",
"and",
"map",
"entries"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/plannodes/NodeSchema.java#L74-L80 | train |
VoltDB/voltdb | src/frontend/org/voltdb/plannodes/NodeSchema.java | NodeSchema.addColumn | public void addColumn(SchemaColumn column) {
int size = m_columns.size();
m_columnsMapHelper.put(column, size);
m_columns.add(column);
} | java | public void addColumn(SchemaColumn column) {
int size = m_columns.size();
m_columnsMapHelper.put(column, size);
m_columns.add(column);
} | [
"public",
"void",
"addColumn",
"(",
"SchemaColumn",
"column",
")",
"{",
"int",
"size",
"=",
"m_columns",
".",
"size",
"(",
")",
";",
"m_columnsMapHelper",
".",
"put",
"(",
"column",
",",
"size",
")",
";",
"m_columns",
".",
"add",
"(",
"column",
")",
";... | Add a column to this schema.
Unless actively modified, updated, or sorted, the column order is
implicitly the order in which columns are added using this call.
Note that it's possible to add the same column to a schema more than once.
In this case we replace the old entry for the column in the map (so it will
stay the same size), the column list will grow by one, and the updated map entry
will point the the second instance of the column in the list. | [
"Add",
"a",
"column",
"to",
"this",
"schema",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/plannodes/NodeSchema.java#L118-L122 | train |
VoltDB/voltdb | src/frontend/org/voltdb/plannodes/NodeSchema.java | NodeSchema.find | public SchemaColumn find(String tableName, String tableAlias,
String columnName, String columnAlias) {
SchemaColumn col = new SchemaColumn(tableName, tableAlias,
columnName, columnAlias);
int index = findIndexOfColumn(col);
if (index != -1) {
return m_columns.get(index);
}
return null;
} | java | public SchemaColumn find(String tableName, String tableAlias,
String columnName, String columnAlias) {
SchemaColumn col = new SchemaColumn(tableName, tableAlias,
columnName, columnAlias);
int index = findIndexOfColumn(col);
if (index != -1) {
return m_columns.get(index);
}
return null;
} | [
"public",
"SchemaColumn",
"find",
"(",
"String",
"tableName",
",",
"String",
"tableAlias",
",",
"String",
"columnName",
",",
"String",
"columnAlias",
")",
"{",
"SchemaColumn",
"col",
"=",
"new",
"SchemaColumn",
"(",
"tableName",
",",
"tableAlias",
",",
"columnNa... | Retrieve the SchemaColumn that matches the provided arguments.
@param tableName The table name of the desired column.
@param tableAlias The table alias of the desired column.
@param columnName The column name of the desired column.
@param columnAlias The column alias of the desired column.
@return The matching SchemaColumn. Returns null if the column wasn't
found. | [
"Retrieve",
"the",
"SchemaColumn",
"that",
"matches",
"the",
"provided",
"arguments",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/plannodes/NodeSchema.java#L173-L182 | train |
VoltDB/voltdb | src/frontend/org/voltdb/plannodes/NodeSchema.java | NodeSchema.sortByTveIndex | void sortByTveIndex(int fromIndex, int toIndex) {
Collections.sort(m_columns.subList(fromIndex, toIndex), TVE_IDX_COMPARE);
} | java | void sortByTveIndex(int fromIndex, int toIndex) {
Collections.sort(m_columns.subList(fromIndex, toIndex), TVE_IDX_COMPARE);
} | [
"void",
"sortByTveIndex",
"(",
"int",
"fromIndex",
",",
"int",
"toIndex",
")",
"{",
"Collections",
".",
"sort",
"(",
"m_columns",
".",
"subList",
"(",
"fromIndex",
",",
"toIndex",
")",
",",
"TVE_IDX_COMPARE",
")",
";",
"}"
] | Sort a sub-range of the schema columns by TVE index. All elements
must be TupleValueExpressions. Modification is made in-place.
@param fromIndex lower bound of range to be sorted, inclusive
@param toIndex upper bound of range to be sorted, exclusive | [
"Sort",
"a",
"sub",
"-",
"range",
"of",
"the",
"schema",
"columns",
"by",
"TVE",
"index",
".",
"All",
"elements",
"must",
"be",
"TupleValueExpressions",
".",
"Modification",
"is",
"made",
"in",
"-",
"place",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/plannodes/NodeSchema.java#L266-L268 | train |
VoltDB/voltdb | src/frontend/org/voltdb/plannodes/NodeSchema.java | NodeSchema.equalsOnlyNames | public boolean equalsOnlyNames(NodeSchema otherSchema) {
if (otherSchema == null) {
return false;
}
if (otherSchema.size() != size()) {
return false;
}
for (int colIndex = 0; colIndex < size(); colIndex++ ) {
SchemaColumn col1 = otherSchema.getColumn(colIndex);
SchemaColumn col2 = m_columns.get(colIndex);
if (col1.compareNames(col2) != 0) {
return false;
}
}
return true;
} | java | public boolean equalsOnlyNames(NodeSchema otherSchema) {
if (otherSchema == null) {
return false;
}
if (otherSchema.size() != size()) {
return false;
}
for (int colIndex = 0; colIndex < size(); colIndex++ ) {
SchemaColumn col1 = otherSchema.getColumn(colIndex);
SchemaColumn col2 = m_columns.get(colIndex);
if (col1.compareNames(col2) != 0) {
return false;
}
}
return true;
} | [
"public",
"boolean",
"equalsOnlyNames",
"(",
"NodeSchema",
"otherSchema",
")",
"{",
"if",
"(",
"otherSchema",
"==",
"null",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"otherSchema",
".",
"size",
"(",
")",
"!=",
"size",
"(",
")",
")",
"{",
"retur... | names are the same. Don't worry about the differentiator field. | [
"names",
"are",
"the",
"same",
".",
"Don",
"t",
"worry",
"about",
"the",
"differentiator",
"field",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/plannodes/NodeSchema.java#L329-L347 | train |
VoltDB/voltdb | src/frontend/org/voltdb/plannodes/NodeSchema.java | NodeSchema.copyAndReplaceWithTVE | NodeSchema copyAndReplaceWithTVE() {
NodeSchema copy = new NodeSchema();
int colIndex = 0;
for (SchemaColumn column : m_columns) {
copy.addColumn(column.copyAndReplaceWithTVE(colIndex));
++colIndex;
}
return copy;
} | java | NodeSchema copyAndReplaceWithTVE() {
NodeSchema copy = new NodeSchema();
int colIndex = 0;
for (SchemaColumn column : m_columns) {
copy.addColumn(column.copyAndReplaceWithTVE(colIndex));
++colIndex;
}
return copy;
} | [
"NodeSchema",
"copyAndReplaceWithTVE",
"(",
")",
"{",
"NodeSchema",
"copy",
"=",
"new",
"NodeSchema",
"(",
")",
";",
"int",
"colIndex",
"=",
"0",
";",
"for",
"(",
"SchemaColumn",
"column",
":",
"m_columns",
")",
"{",
"copy",
".",
"addColumn",
"(",
"column"... | Returns a copy of this NodeSchema but with all non-TVE expressions
replaced with an appropriate TVE. This is used primarily when generating
a node's output schema based on its childrens' schema; we want to
carry the columns across but leave any non-TVE expressions behind. | [
"Returns",
"a",
"copy",
"of",
"this",
"NodeSchema",
"but",
"with",
"all",
"non",
"-",
"TVE",
"expressions",
"replaced",
"with",
"an",
"appropriate",
"TVE",
".",
"This",
"is",
"used",
"primarily",
"when",
"generating",
"a",
"node",
"s",
"output",
"schema",
... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/plannodes/NodeSchema.java#L364-L372 | train |
VoltDB/voltdb | src/frontend/org/voltdb/plannodes/NodeSchema.java | NodeSchema.harmonize | public boolean harmonize(NodeSchema otherSchema, String schemaKindName) {
if (size() != otherSchema.size()) {
throw new PlanningErrorException(
"The "
+ schemaKindName + "schema and the statement output schemas have different lengths.");
}
boolean changedSomething = false;
for (int idx = 0; idx < size(); idx += 1) {
SchemaColumn myColumn = getColumn(idx);
SchemaColumn otherColumn = otherSchema.getColumn(idx);
VoltType myType = myColumn.getValueType();
VoltType otherType = otherColumn.getValueType();
VoltType commonType = myType;
if (! myType.canExactlyRepresentAnyValueOf(otherType)) {
if (otherType.canExactlyRepresentAnyValueOf(myType)) {
commonType = otherType;
}
else {
throw new PlanningErrorException(
"The "
+ schemaKindName
+ " column type and the statement output type for column "
+ idx
+ " are incompatible.");
}
}
if (myType != commonType) {
changedSomething = true;
myColumn.setValueType(commonType);
}
// Now determine the length, and the "in bytes" flag if needed
assert (myType.isVariableLength() == otherType.isVariableLength());
// The type will be one of:
// - fixed size
// - VARCHAR (need special logic for bytes vs. chars)
// - Some other variable length type
int commonSize;
if (! myType.isVariableLength()) {
commonSize = myType.getLengthInBytesForFixedTypesWithoutCheck();
}
else if (myType == VoltType.STRING) {
boolean myInBytes = myColumn.getInBytes();
boolean otherInBytes = otherColumn.getInBytes();
if (myInBytes == otherInBytes) {
commonSize = Math.max(myColumn.getValueSize(), otherColumn.getValueSize());
}
else {
// one is in bytes and the other is in characters
int mySizeInBytes = (myColumn.getInBytes() ? 1 : 4) * myColumn.getValueSize();
int otherSizeInBytes = (otherColumn.getInBytes() ? 1 : 4) * otherColumn.getValueSize();
if (! myColumn.getInBytes()) {
myColumn.setInBytes(true);
changedSomething = true;
}
commonSize = Math.max(mySizeInBytes, otherSizeInBytes);
if (commonSize > VoltType.MAX_VALUE_LENGTH) {
commonSize = VoltType.MAX_VALUE_LENGTH;
}
}
}
else {
commonSize = Math.max(myColumn.getValueSize(), otherColumn.getValueSize());
}
if (commonSize != myColumn.getValueSize()) {
myColumn.setValueSize(commonSize);
changedSomething = true;
}
}
return changedSomething;
} | java | public boolean harmonize(NodeSchema otherSchema, String schemaKindName) {
if (size() != otherSchema.size()) {
throw new PlanningErrorException(
"The "
+ schemaKindName + "schema and the statement output schemas have different lengths.");
}
boolean changedSomething = false;
for (int idx = 0; idx < size(); idx += 1) {
SchemaColumn myColumn = getColumn(idx);
SchemaColumn otherColumn = otherSchema.getColumn(idx);
VoltType myType = myColumn.getValueType();
VoltType otherType = otherColumn.getValueType();
VoltType commonType = myType;
if (! myType.canExactlyRepresentAnyValueOf(otherType)) {
if (otherType.canExactlyRepresentAnyValueOf(myType)) {
commonType = otherType;
}
else {
throw new PlanningErrorException(
"The "
+ schemaKindName
+ " column type and the statement output type for column "
+ idx
+ " are incompatible.");
}
}
if (myType != commonType) {
changedSomething = true;
myColumn.setValueType(commonType);
}
// Now determine the length, and the "in bytes" flag if needed
assert (myType.isVariableLength() == otherType.isVariableLength());
// The type will be one of:
// - fixed size
// - VARCHAR (need special logic for bytes vs. chars)
// - Some other variable length type
int commonSize;
if (! myType.isVariableLength()) {
commonSize = myType.getLengthInBytesForFixedTypesWithoutCheck();
}
else if (myType == VoltType.STRING) {
boolean myInBytes = myColumn.getInBytes();
boolean otherInBytes = otherColumn.getInBytes();
if (myInBytes == otherInBytes) {
commonSize = Math.max(myColumn.getValueSize(), otherColumn.getValueSize());
}
else {
// one is in bytes and the other is in characters
int mySizeInBytes = (myColumn.getInBytes() ? 1 : 4) * myColumn.getValueSize();
int otherSizeInBytes = (otherColumn.getInBytes() ? 1 : 4) * otherColumn.getValueSize();
if (! myColumn.getInBytes()) {
myColumn.setInBytes(true);
changedSomething = true;
}
commonSize = Math.max(mySizeInBytes, otherSizeInBytes);
if (commonSize > VoltType.MAX_VALUE_LENGTH) {
commonSize = VoltType.MAX_VALUE_LENGTH;
}
}
}
else {
commonSize = Math.max(myColumn.getValueSize(), otherColumn.getValueSize());
}
if (commonSize != myColumn.getValueSize()) {
myColumn.setValueSize(commonSize);
changedSomething = true;
}
}
return changedSomething;
} | [
"public",
"boolean",
"harmonize",
"(",
"NodeSchema",
"otherSchema",
",",
"String",
"schemaKindName",
")",
"{",
"if",
"(",
"size",
"(",
")",
"!=",
"otherSchema",
".",
"size",
"(",
")",
")",
"{",
"throw",
"new",
"PlanningErrorException",
"(",
"\"The \"",
"+",
... | Modifies this schema such that its columns can accommodate both values of its own types
and that of otherSchema. Does not modify otherSchema.
@param otherSchema The schema whose values we would like to accommodate in this schema
@param schemaKindName The kind of schema we are harmonizing, for error reporting
@return True iff we have changed something in the schema. | [
"Modifies",
"this",
"schema",
"such",
"that",
"its",
"columns",
"can",
"accommodate",
"both",
"values",
"of",
"its",
"own",
"types",
"and",
"that",
"of",
"otherSchema",
".",
"Does",
"not",
"modify",
"otherSchema",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/plannodes/NodeSchema.java#L436-L511 | train |
VoltDB/voltdb | third_party/java/src/org/HdrHistogram_voltpatches/HistogramIterationValue.java | HistogramIterationValue.set | void set(final long valueIteratedTo, final long valueIteratedFrom, final long countAtValueIteratedTo,
final long countInThisIterationStep, final long totalCountToThisValue, final long totalValueToThisValue,
final double percentile, final double percentileLevelIteratedTo, double integerToDoubleValueConversionRatio) {
this.valueIteratedTo = valueIteratedTo;
this.valueIteratedFrom = valueIteratedFrom;
this.countAtValueIteratedTo = countAtValueIteratedTo;
this.countAddedInThisIterationStep = countInThisIterationStep;
this.totalCountToThisValue = totalCountToThisValue;
this.totalValueToThisValue = totalValueToThisValue;
this.percentile = percentile;
this.percentileLevelIteratedTo = percentileLevelIteratedTo;
this.integerToDoubleValueConversionRatio = integerToDoubleValueConversionRatio;
} | java | void set(final long valueIteratedTo, final long valueIteratedFrom, final long countAtValueIteratedTo,
final long countInThisIterationStep, final long totalCountToThisValue, final long totalValueToThisValue,
final double percentile, final double percentileLevelIteratedTo, double integerToDoubleValueConversionRatio) {
this.valueIteratedTo = valueIteratedTo;
this.valueIteratedFrom = valueIteratedFrom;
this.countAtValueIteratedTo = countAtValueIteratedTo;
this.countAddedInThisIterationStep = countInThisIterationStep;
this.totalCountToThisValue = totalCountToThisValue;
this.totalValueToThisValue = totalValueToThisValue;
this.percentile = percentile;
this.percentileLevelIteratedTo = percentileLevelIteratedTo;
this.integerToDoubleValueConversionRatio = integerToDoubleValueConversionRatio;
} | [
"void",
"set",
"(",
"final",
"long",
"valueIteratedTo",
",",
"final",
"long",
"valueIteratedFrom",
",",
"final",
"long",
"countAtValueIteratedTo",
",",
"final",
"long",
"countInThisIterationStep",
",",
"final",
"long",
"totalCountToThisValue",
",",
"final",
"long",
... | Set is all-or-nothing to avoid the potential for accidental omission of some values... | [
"Set",
"is",
"all",
"-",
"or",
"-",
"nothing",
"to",
"avoid",
"the",
"potential",
"for",
"accidental",
"omission",
"of",
"some",
"values",
"..."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/HdrHistogram_voltpatches/HistogramIterationValue.java#L48-L60 | train |
VoltDB/voltdb | src/frontend/org/voltdb/expressions/ParameterValueExpression.java | ParameterValueExpression.bindingToIndexedExpression | @Override
public List<AbstractExpression> bindingToIndexedExpression(AbstractExpression expr) {
if (m_originalValue == null || ! m_originalValue.equals(expr)) {
return null;
}
// This parameter's value was matched, so return this as one bound parameter.
List<AbstractExpression> result = new ArrayList<AbstractExpression>();
result.add(this);
return result;
} | java | @Override
public List<AbstractExpression> bindingToIndexedExpression(AbstractExpression expr) {
if (m_originalValue == null || ! m_originalValue.equals(expr)) {
return null;
}
// This parameter's value was matched, so return this as one bound parameter.
List<AbstractExpression> result = new ArrayList<AbstractExpression>();
result.add(this);
return result;
} | [
"@",
"Override",
"public",
"List",
"<",
"AbstractExpression",
">",
"bindingToIndexedExpression",
"(",
"AbstractExpression",
"expr",
")",
"{",
"if",
"(",
"m_originalValue",
"==",
"null",
"||",
"!",
"m_originalValue",
".",
"equals",
"(",
"expr",
")",
")",
"{",
"... | query in which that constant differs. | [
"query",
"in",
"which",
"that",
"constant",
"differs",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/expressions/ParameterValueExpression.java#L227-L236 | train |
VoltDB/voltdb | src/frontend/org/voltdb/StoredProcedureInvocation.java | StoredProcedureInvocation.getParameterAtIndex | Object getParameterAtIndex(int partitionIndex) {
try {
if (serializedParams != null) {
return ParameterSet.getParameterAtIndex(partitionIndex, serializedParams.duplicate());
} else {
return params.get().getParam(partitionIndex);
}
}
catch (Exception ex) {
throw new RuntimeException("Invalid partitionIndex: " + partitionIndex, ex);
}
} | java | Object getParameterAtIndex(int partitionIndex) {
try {
if (serializedParams != null) {
return ParameterSet.getParameterAtIndex(partitionIndex, serializedParams.duplicate());
} else {
return params.get().getParam(partitionIndex);
}
}
catch (Exception ex) {
throw new RuntimeException("Invalid partitionIndex: " + partitionIndex, ex);
}
} | [
"Object",
"getParameterAtIndex",
"(",
"int",
"partitionIndex",
")",
"{",
"try",
"{",
"if",
"(",
"serializedParams",
"!=",
"null",
")",
"{",
"return",
"ParameterSet",
".",
"getParameterAtIndex",
"(",
"partitionIndex",
",",
"serializedParams",
".",
"duplicate",
"(",... | Read into an serialized parameter buffer to extract a single parameter | [
"Read",
"into",
"an",
"serialized",
"parameter",
"buffer",
"to",
"extract",
"a",
"single",
"parameter"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/StoredProcedureInvocation.java#L189-L200 | train |
VoltDB/voltdb | src/frontend/org/voltdb/StoredProcedureInvocation.java | StoredProcedureInvocation.flattenToBufferForOriginalVersion | public void flattenToBufferForOriginalVersion(ByteBuffer buf) throws IOException
{
assert((params != null) || (serializedParams != null));
// for self-check assertion
int startPosition = buf.position();
buf.put(ProcedureInvocationType.ORIGINAL.getValue());
SerializationHelper.writeVarbinary(getProcNameBytes(), buf);
buf.putLong(clientHandle);
serializeParams(buf);
int len = buf.position() - startPosition;
assert(len == getSerializedSizeForOriginalVersion());
} | java | public void flattenToBufferForOriginalVersion(ByteBuffer buf) throws IOException
{
assert((params != null) || (serializedParams != null));
// for self-check assertion
int startPosition = buf.position();
buf.put(ProcedureInvocationType.ORIGINAL.getValue());
SerializationHelper.writeVarbinary(getProcNameBytes(), buf);
buf.putLong(clientHandle);
serializeParams(buf);
int len = buf.position() - startPosition;
assert(len == getSerializedSizeForOriginalVersion());
} | [
"public",
"void",
"flattenToBufferForOriginalVersion",
"(",
"ByteBuffer",
"buf",
")",
"throws",
"IOException",
"{",
"assert",
"(",
"(",
"params",
"!=",
"null",
")",
"||",
"(",
"serializedParams",
"!=",
"null",
")",
")",
";",
"// for self-check assertion",
"int",
... | Serializes this SPI in the original serialization version.
This is currently used by DR. | [
"Serializes",
"this",
"SPI",
"in",
"the",
"original",
"serialization",
"version",
".",
"This",
"is",
"currently",
"used",
"by",
"DR",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/StoredProcedureInvocation.java#L349-L366 | train |
VoltDB/voltdb | src/frontend/org/voltdb/importclient/kafka/util/DurableTracker.java | DurableTracker.submit | @Override
public synchronized void submit(long offset) {
if (submittedOffset == -1L && offset >= 0) {
committedOffsets[idx(offset)] = safeOffset = submittedOffset = offset;
}
if (firstOffset == -1L) {
firstOffset = offset;
}
if ((offset - safeOffset) >= committedOffsets.length) {
offerOffset = offset;
try {
wait(m_gapFullWait);
} catch (InterruptedException e) {
LOGGER.rateLimitedLog(LOG_SUPPRESSION_INTERVAL_SECONDS,
Level.WARN, e, "CommitTracker wait was interrupted for group " + consumerGroup + " topic " + topic + " partition " + partition);
}
}
if (offset > submittedOffset) {
submittedOffset = offset;
}
} | java | @Override
public synchronized void submit(long offset) {
if (submittedOffset == -1L && offset >= 0) {
committedOffsets[idx(offset)] = safeOffset = submittedOffset = offset;
}
if (firstOffset == -1L) {
firstOffset = offset;
}
if ((offset - safeOffset) >= committedOffsets.length) {
offerOffset = offset;
try {
wait(m_gapFullWait);
} catch (InterruptedException e) {
LOGGER.rateLimitedLog(LOG_SUPPRESSION_INTERVAL_SECONDS,
Level.WARN, e, "CommitTracker wait was interrupted for group " + consumerGroup + " topic " + topic + " partition " + partition);
}
}
if (offset > submittedOffset) {
submittedOffset = offset;
}
} | [
"@",
"Override",
"public",
"synchronized",
"void",
"submit",
"(",
"long",
"offset",
")",
"{",
"if",
"(",
"submittedOffset",
"==",
"-",
"1L",
"&&",
"offset",
">=",
"0",
")",
"{",
"committedOffsets",
"[",
"idx",
"(",
"offset",
")",
"]",
"=",
"safeOffset",
... | submit an offset while consuming a message and record the maximal submitted offset | [
"submit",
"an",
"offset",
"while",
"consuming",
"a",
"message",
"and",
"record",
"the",
"maximal",
"submitted",
"offset"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/importclient/kafka/util/DurableTracker.java#L73-L93 | train |
VoltDB/voltdb | src/frontend/org/voltdb/importclient/kafka/util/DurableTracker.java | DurableTracker.commit | @Override
public synchronized long commit(long offset) {
if (offset <= submittedOffset && offset > safeOffset) {
int ggap = (int)Math.min(committedOffsets.length, offset-safeOffset);
if (ggap == committedOffsets.length) {
LOGGER.rateLimitedLog(LOG_SUPPRESSION_INTERVAL_SECONDS ,Level.WARN,
null, "CommitTracker moving topic commit point from %d to %d for topic "
+ topic + " partition " + partition + " group:" + consumerGroup, safeOffset, (offset - committedOffsets.length + 1)
);
safeOffset = offset - committedOffsets.length + 1;
committedOffsets[idx(safeOffset)] = safeOffset;
}
committedOffsets[idx(offset)] = offset;
while (ggap > 0 && committedOffsets[idx(safeOffset)]+1 == committedOffsets[idx(safeOffset+1)]) {
++safeOffset;
}
if (offerOffset >=0 && (offerOffset-safeOffset) < committedOffsets.length) {
offerOffset = -1L;
notify();
}
}
if (offset == firstOffset) {
firstOffsetCommitted = true;
}
return safeOffset;
} | java | @Override
public synchronized long commit(long offset) {
if (offset <= submittedOffset && offset > safeOffset) {
int ggap = (int)Math.min(committedOffsets.length, offset-safeOffset);
if (ggap == committedOffsets.length) {
LOGGER.rateLimitedLog(LOG_SUPPRESSION_INTERVAL_SECONDS ,Level.WARN,
null, "CommitTracker moving topic commit point from %d to %d for topic "
+ topic + " partition " + partition + " group:" + consumerGroup, safeOffset, (offset - committedOffsets.length + 1)
);
safeOffset = offset - committedOffsets.length + 1;
committedOffsets[idx(safeOffset)] = safeOffset;
}
committedOffsets[idx(offset)] = offset;
while (ggap > 0 && committedOffsets[idx(safeOffset)]+1 == committedOffsets[idx(safeOffset+1)]) {
++safeOffset;
}
if (offerOffset >=0 && (offerOffset-safeOffset) < committedOffsets.length) {
offerOffset = -1L;
notify();
}
}
if (offset == firstOffset) {
firstOffsetCommitted = true;
}
return safeOffset;
} | [
"@",
"Override",
"public",
"synchronized",
"long",
"commit",
"(",
"long",
"offset",
")",
"{",
"if",
"(",
"offset",
"<=",
"submittedOffset",
"&&",
"offset",
">",
"safeOffset",
")",
"{",
"int",
"ggap",
"=",
"(",
"int",
")",
"Math",
".",
"min",
"(",
"comm... | VoltDB. It will be recorded in committedOffsets and calculate the offset-safeOffset, which is safe to commit to Kafka | [
"VoltDB",
".",
"It",
"will",
"be",
"recorded",
"in",
"committedOffsets",
"and",
"calculate",
"the",
"offset",
"-",
"safeOffset",
"which",
"is",
"safe",
"to",
"commit",
"to",
"Kafka"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/importclient/kafka/util/DurableTracker.java#L110-L136 | train |
VoltDB/voltdb | src/frontend/org/voltcore/utils/RateLimitedLogger.java | RateLimitedLogger.log | public void log(long now, Level level, Throwable cause, String stemformat, Object...args) {
if (now - m_lastLogTime > m_maxLogIntervalMillis) {
synchronized (this) {
if (now - m_lastLogTime > m_maxLogIntervalMillis) {
String message = formatMessage(cause, stemformat, args);
switch(level) {
case DEBUG:
m_logger.debug(message); break;
case ERROR:
m_logger.error(message); break;
case FATAL:
m_logger.fatal(message); break;
case INFO:
m_logger.info(message); break;
case TRACE:
m_logger.trace(message); break;
case WARN:
m_logger.warn(message); break;
}
m_lastLogTime = now;
}
}
}
} | java | public void log(long now, Level level, Throwable cause, String stemformat, Object...args) {
if (now - m_lastLogTime > m_maxLogIntervalMillis) {
synchronized (this) {
if (now - m_lastLogTime > m_maxLogIntervalMillis) {
String message = formatMessage(cause, stemformat, args);
switch(level) {
case DEBUG:
m_logger.debug(message); break;
case ERROR:
m_logger.error(message); break;
case FATAL:
m_logger.fatal(message); break;
case INFO:
m_logger.info(message); break;
case TRACE:
m_logger.trace(message); break;
case WARN:
m_logger.warn(message); break;
}
m_lastLogTime = now;
}
}
}
} | [
"public",
"void",
"log",
"(",
"long",
"now",
",",
"Level",
"level",
",",
"Throwable",
"cause",
",",
"String",
"stemformat",
",",
"Object",
"...",
"args",
")",
"{",
"if",
"(",
"now",
"-",
"m_lastLogTime",
">",
"m_maxLogIntervalMillis",
")",
"{",
"synchroniz... | This variant delays the formatting of the string message until it is actually logged
@param now
@param level a {@link Level debug level}
@param cause evidentiary exception
@param stemformat a {@link String#format(String, Object...) string format}
@param args format arguments | [
"This",
"variant",
"delays",
"the",
"formatting",
"of",
"the",
"string",
"message",
"until",
"it",
"is",
"actually",
"logged"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltcore/utils/RateLimitedLogger.java#L91-L114 | train |
VoltDB/voltdb | src/frontend/org/voltdb/iv2/ElasticJoinProducer.java | ElasticJoinProducer.sendFirstFragResponse | private void sendFirstFragResponse()
{
if (ELASTICLOG.isDebugEnabled()) {
ELASTICLOG.debug("P" + m_partitionId + " sending first fragment response to coordinator " +
CoreUtils.hsIdToString(m_coordinatorHsId));
}
RejoinMessage msg = new RejoinMessage(m_mailbox.getHSId(),
RejoinMessage.Type.FIRST_FRAGMENT_RECEIVED);
m_mailbox.send(m_coordinatorHsId, msg);
m_firstFragResponseSent = true;
} | java | private void sendFirstFragResponse()
{
if (ELASTICLOG.isDebugEnabled()) {
ELASTICLOG.debug("P" + m_partitionId + " sending first fragment response to coordinator " +
CoreUtils.hsIdToString(m_coordinatorHsId));
}
RejoinMessage msg = new RejoinMessage(m_mailbox.getHSId(),
RejoinMessage.Type.FIRST_FRAGMENT_RECEIVED);
m_mailbox.send(m_coordinatorHsId, msg);
m_firstFragResponseSent = true;
} | [
"private",
"void",
"sendFirstFragResponse",
"(",
")",
"{",
"if",
"(",
"ELASTICLOG",
".",
"isDebugEnabled",
"(",
")",
")",
"{",
"ELASTICLOG",
".",
"debug",
"(",
"\"P\"",
"+",
"m_partitionId",
"+",
"\" sending first fragment response to coordinator \"",
"+",
"CoreUtil... | Notify the coordinator that this site has received the first fragment message | [
"Notify",
"the",
"coordinator",
"that",
"this",
"site",
"has",
"received",
"the",
"first",
"fragment",
"message"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/iv2/ElasticJoinProducer.java#L147-L157 | train |
VoltDB/voltdb | src/frontend/org/voltdb/iv2/ElasticJoinProducer.java | ElasticJoinProducer.runForBlockingDataTransfer | private void runForBlockingDataTransfer(SiteProcedureConnection siteConnection)
{
boolean sourcesReady = false;
RestoreWork restoreWork = m_dataSink.poll(m_snapshotBufferAllocator);
if (restoreWork != null) {
restoreBlock(restoreWork, siteConnection);
sourcesReady = true;
}
// The completion monitor may fire even if m_dataSink has not reached EOF in the case that there's no
// replicated table in the database, so check for both conditions.
if (m_dataSink.isEOF() || m_snapshotCompletionMonitor.isDone()) {
// No more data from this data sink, close and remove it from the list
m_dataSink.close();
if (m_streamSnapshotMb != null) {
VoltDB.instance().getHostMessenger().removeMailbox(m_streamSnapshotMb.getHSId());
m_streamSnapshotMb = null;
ELASTICLOG.debug(m_whoami + " data transfer is finished");
}
if (m_snapshotCompletionMonitor.isDone()) {
try {
SnapshotCompletionEvent event = m_snapshotCompletionMonitor.get();
siteConnection.setDRProtocolVersion(event.drVersion);
assert(event != null);
ELASTICLOG.debug("P" + m_partitionId + " noticed data transfer completion");
m_completionAction.setSnapshotTxnId(event.multipartTxnId);
setJoinComplete(siteConnection,
event.exportSequenceNumbers,
event.drSequenceNumbers,
event.drMixedClusterSizeConsumerState,
false /* requireExistingSequenceNumbers */,
event.clusterCreateTime);
} catch (InterruptedException e) {
// isDone() already returned true, this shouldn't happen
VoltDB.crashLocalVoltDB("Impossible interruption happend", true, e);
} catch (ExecutionException e) {
VoltDB.crashLocalVoltDB("Error waiting for snapshot to finish", true, e);
}
} else {
m_taskQueue.offer(this);
}
} else {
// The sources are not set up yet, don't block the site,
// return here and retry later.
returnToTaskQueue(sourcesReady);
}
} | java | private void runForBlockingDataTransfer(SiteProcedureConnection siteConnection)
{
boolean sourcesReady = false;
RestoreWork restoreWork = m_dataSink.poll(m_snapshotBufferAllocator);
if (restoreWork != null) {
restoreBlock(restoreWork, siteConnection);
sourcesReady = true;
}
// The completion monitor may fire even if m_dataSink has not reached EOF in the case that there's no
// replicated table in the database, so check for both conditions.
if (m_dataSink.isEOF() || m_snapshotCompletionMonitor.isDone()) {
// No more data from this data sink, close and remove it from the list
m_dataSink.close();
if (m_streamSnapshotMb != null) {
VoltDB.instance().getHostMessenger().removeMailbox(m_streamSnapshotMb.getHSId());
m_streamSnapshotMb = null;
ELASTICLOG.debug(m_whoami + " data transfer is finished");
}
if (m_snapshotCompletionMonitor.isDone()) {
try {
SnapshotCompletionEvent event = m_snapshotCompletionMonitor.get();
siteConnection.setDRProtocolVersion(event.drVersion);
assert(event != null);
ELASTICLOG.debug("P" + m_partitionId + " noticed data transfer completion");
m_completionAction.setSnapshotTxnId(event.multipartTxnId);
setJoinComplete(siteConnection,
event.exportSequenceNumbers,
event.drSequenceNumbers,
event.drMixedClusterSizeConsumerState,
false /* requireExistingSequenceNumbers */,
event.clusterCreateTime);
} catch (InterruptedException e) {
// isDone() already returned true, this shouldn't happen
VoltDB.crashLocalVoltDB("Impossible interruption happend", true, e);
} catch (ExecutionException e) {
VoltDB.crashLocalVoltDB("Error waiting for snapshot to finish", true, e);
}
} else {
m_taskQueue.offer(this);
}
} else {
// The sources are not set up yet, don't block the site,
// return here and retry later.
returnToTaskQueue(sourcesReady);
}
} | [
"private",
"void",
"runForBlockingDataTransfer",
"(",
"SiteProcedureConnection",
"siteConnection",
")",
"{",
"boolean",
"sourcesReady",
"=",
"false",
";",
"RestoreWork",
"restoreWork",
"=",
"m_dataSink",
".",
"poll",
"(",
"m_snapshotBufferAllocator",
")",
";",
"if",
"... | Blocking transfer all partitioned table data and notify the coordinator.
@param siteConnection | [
"Blocking",
"transfer",
"all",
"partitioned",
"table",
"data",
"and",
"notify",
"the",
"coordinator",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/iv2/ElasticJoinProducer.java#L163-L212 | train |
VoltDB/voltdb | src/frontend/org/voltdb/modular/ModuleManager.java | ModuleManager.getService | public <T> T getService(URI bundleURI, Class<T> svcClazz) {
return m_bundles.getService(bundleURI, svcClazz);
} | java | public <T> T getService(URI bundleURI, Class<T> svcClazz) {
return m_bundles.getService(bundleURI, svcClazz);
} | [
"public",
"<",
"T",
">",
"T",
"getService",
"(",
"URI",
"bundleURI",
",",
"Class",
"<",
"T",
">",
"svcClazz",
")",
"{",
"return",
"m_bundles",
".",
"getService",
"(",
"bundleURI",
",",
"svcClazz",
")",
";",
"}"
] | Gets the service from the given bundle jar uri. Loads and starts the bundle
if it isn't yet loaded
@param bundleURI bundle jar URI
@param svcClazz the service class exposed by the bundle jar
@return a reference to an instance of the service class | [
"Gets",
"the",
"service",
"from",
"the",
"given",
"bundle",
"jar",
"uri",
".",
"Loads",
"and",
"starts",
"the",
"bundle",
"if",
"it",
"isn",
"t",
"yet",
"loaded"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/modular/ModuleManager.java#L187-L189 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/RowAVLDisk.java | RowAVLDisk.setPos | public void setPos(int pos) {
position = pos;
NodeAVL n = nPrimaryNode;
while (n != null) {
((NodeAVLDisk) n).iData = position;
n = n.nNext;
}
} | java | public void setPos(int pos) {
position = pos;
NodeAVL n = nPrimaryNode;
while (n != null) {
((NodeAVLDisk) n).iData = position;
n = n.nNext;
}
} | [
"public",
"void",
"setPos",
"(",
"int",
"pos",
")",
"{",
"position",
"=",
"pos",
";",
"NodeAVL",
"n",
"=",
"nPrimaryNode",
";",
"while",
"(",
"n",
"!=",
"null",
")",
"{",
"(",
"(",
"NodeAVLDisk",
")",
"n",
")",
".",
"iData",
"=",
"position",
";",
... | Sets the file position for the row
@param pos position in data file | [
"Sets",
"the",
"file",
"position",
"for",
"the",
"row"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/RowAVLDisk.java#L208-L218 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/RowAVLDisk.java | RowAVLDisk.setNewNodes | void setNewNodes() {
int indexcount = tTable.getIndexCount();
nPrimaryNode = new NodeAVLDisk(this, 0);
NodeAVL n = nPrimaryNode;
for (int i = 1; i < indexcount; i++) {
n.nNext = new NodeAVLDisk(this, i);
n = n.nNext;
}
} | java | void setNewNodes() {
int indexcount = tTable.getIndexCount();
nPrimaryNode = new NodeAVLDisk(this, 0);
NodeAVL n = nPrimaryNode;
for (int i = 1; i < indexcount; i++) {
n.nNext = new NodeAVLDisk(this, i);
n = n.nNext;
}
} | [
"void",
"setNewNodes",
"(",
")",
"{",
"int",
"indexcount",
"=",
"tTable",
".",
"getIndexCount",
"(",
")",
";",
"nPrimaryNode",
"=",
"new",
"NodeAVLDisk",
"(",
"this",
",",
"0",
")",
";",
"NodeAVL",
"n",
"=",
"nPrimaryNode",
";",
"for",
"(",
"int",
"i",... | used in CachedDataRow | [
"used",
"in",
"CachedDataRow"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/RowAVLDisk.java#L316-L328 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/RowAVLDisk.java | RowAVLDisk.write | public void write(RowOutputInterface out) {
try {
writeNodes(out);
if (hasDataChanged) {
out.writeData(rowData, tTable.colTypes);
out.writeEnd();
hasDataChanged = false;
}
} catch (IOException e) {}
} | java | public void write(RowOutputInterface out) {
try {
writeNodes(out);
if (hasDataChanged) {
out.writeData(rowData, tTable.colTypes);
out.writeEnd();
hasDataChanged = false;
}
} catch (IOException e) {}
} | [
"public",
"void",
"write",
"(",
"RowOutputInterface",
"out",
")",
"{",
"try",
"{",
"writeNodes",
"(",
"out",
")",
";",
"if",
"(",
"hasDataChanged",
")",
"{",
"out",
".",
"writeData",
"(",
"rowData",
",",
"tTable",
".",
"colTypes",
")",
";",
"out",
".",... | Used exclusively by Cache to save the row to disk. New implementation in
1.7.2 writes out only the Node data if the table row data has not
changed. This situation accounts for the majority of invocations as for
each row deleted or inserted, the Nodes for several other rows will
change. | [
"Used",
"exclusively",
"by",
"Cache",
"to",
"save",
"the",
"row",
"to",
"disk",
".",
"New",
"implementation",
"in",
"1",
".",
"7",
".",
"2",
"writes",
"out",
"only",
"the",
"Node",
"data",
"if",
"the",
"table",
"row",
"data",
"has",
"not",
"changed",
... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/RowAVLDisk.java#L345-L357 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/RowAVLDisk.java | RowAVLDisk.writeNodes | private void writeNodes(RowOutputInterface out) throws IOException {
out.writeSize(storageSize);
NodeAVL n = nPrimaryNode;
while (n != null) {
n.write(out);
n = n.nNext;
}
hasNodesChanged = false;
} | java | private void writeNodes(RowOutputInterface out) throws IOException {
out.writeSize(storageSize);
NodeAVL n = nPrimaryNode;
while (n != null) {
n.write(out);
n = n.nNext;
}
hasNodesChanged = false;
} | [
"private",
"void",
"writeNodes",
"(",
"RowOutputInterface",
"out",
")",
"throws",
"IOException",
"{",
"out",
".",
"writeSize",
"(",
"storageSize",
")",
";",
"NodeAVL",
"n",
"=",
"nPrimaryNode",
";",
"while",
"(",
"n",
"!=",
"null",
")",
"{",
"n",
".",
"w... | Writes the Nodes, immediately after the row size.
@param out
@throws IOException | [
"Writes",
"the",
"Nodes",
"immediately",
"after",
"the",
"row",
"size",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/RowAVLDisk.java#L387-L400 | train |
VoltDB/voltdb | src/frontend/org/voltdb/exceptions/SerializableException.java | SerializableException.serializeToBuffer | public void serializeToBuffer(ByteBuffer b) {
assert(getSerializedSize() <= b.remaining());
b.putInt(getSerializedSize() - 4);
b.put((byte)getExceptionType().ordinal());
if (m_message != null) {
final byte messageBytes[] = m_message.getBytes();
b.putInt(messageBytes.length);
b.put(messageBytes);
} else {
b.putInt(0);
}
p_serializeToBuffer(b);
} | java | public void serializeToBuffer(ByteBuffer b) {
assert(getSerializedSize() <= b.remaining());
b.putInt(getSerializedSize() - 4);
b.put((byte)getExceptionType().ordinal());
if (m_message != null) {
final byte messageBytes[] = m_message.getBytes();
b.putInt(messageBytes.length);
b.put(messageBytes);
} else {
b.putInt(0);
}
p_serializeToBuffer(b);
} | [
"public",
"void",
"serializeToBuffer",
"(",
"ByteBuffer",
"b",
")",
"{",
"assert",
"(",
"getSerializedSize",
"(",
")",
"<=",
"b",
".",
"remaining",
"(",
")",
")",
";",
"b",
".",
"putInt",
"(",
"getSerializedSize",
"(",
")",
"-",
"4",
")",
";",
"b",
"... | Serialize this exception to the supplied byte buffer
@param b ByteBuffer to serialize this exception to | [
"Serialize",
"this",
"exception",
"to",
"the",
"supplied",
"byte",
"buffer"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/exceptions/SerializableException.java#L189-L201 | train |
VoltDB/voltdb | src/frontend/org/voltdb/StatsSource.java | StatsSource.populateColumnSchema | protected void populateColumnSchema(ArrayList<ColumnInfo> columns) {
columns.add(new ColumnInfo("TIMESTAMP", VoltType.BIGINT));
columns.add(new ColumnInfo(VoltSystemProcedure.CNAME_HOST_ID,
VoltSystemProcedure.CTYPE_ID));
columns.add(new ColumnInfo("HOSTNAME", VoltType.STRING));
} | java | protected void populateColumnSchema(ArrayList<ColumnInfo> columns) {
columns.add(new ColumnInfo("TIMESTAMP", VoltType.BIGINT));
columns.add(new ColumnInfo(VoltSystemProcedure.CNAME_HOST_ID,
VoltSystemProcedure.CTYPE_ID));
columns.add(new ColumnInfo("HOSTNAME", VoltType.STRING));
} | [
"protected",
"void",
"populateColumnSchema",
"(",
"ArrayList",
"<",
"ColumnInfo",
">",
"columns",
")",
"{",
"columns",
".",
"add",
"(",
"new",
"ColumnInfo",
"(",
"\"TIMESTAMP\"",
",",
"VoltType",
".",
"BIGINT",
")",
")",
";",
"columns",
".",
"add",
"(",
"n... | Called from the constructor to generate the column schema at run time.
Derived classes need to override this method in order to specify the
columns they will be adding. The first line must always be a call the
superclasses version of populateColumnSchema
in order to ensure the columns are add to the list in the right order.
@param columns Output list for the column schema. | [
"Called",
"from",
"the",
"constructor",
"to",
"generate",
"the",
"column",
"schema",
"at",
"run",
"time",
".",
"Derived",
"classes",
"need",
"to",
"override",
"this",
"method",
"in",
"order",
"to",
"specify",
"the",
"columns",
"they",
"will",
"be",
"adding",... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/StatsSource.java#L93-L98 | train |
VoltDB/voltdb | src/frontend/org/voltdb/StatsSource.java | StatsSource.getStatsRows | public Object[][] getStatsRows(boolean interval, final Long now) {
this.now = now;
/*
* Synchronizing on this allows derived classes to maintain thread safety
*/
synchronized (this) {
Iterator<Object> i = getStatsRowKeyIterator(interval);
ArrayList<Object[]> rows = new ArrayList<Object[]>();
while (i.hasNext()) {
Object rowKey = i.next();
Object rowValues[] = new Object[columns.size()];
updateStatsRow(rowKey, rowValues);
rows.add(rowValues);
}
return rows.toArray(new Object[0][]);
}
} | java | public Object[][] getStatsRows(boolean interval, final Long now) {
this.now = now;
/*
* Synchronizing on this allows derived classes to maintain thread safety
*/
synchronized (this) {
Iterator<Object> i = getStatsRowKeyIterator(interval);
ArrayList<Object[]> rows = new ArrayList<Object[]>();
while (i.hasNext()) {
Object rowKey = i.next();
Object rowValues[] = new Object[columns.size()];
updateStatsRow(rowKey, rowValues);
rows.add(rowValues);
}
return rows.toArray(new Object[0][]);
}
} | [
"public",
"Object",
"[",
"]",
"[",
"]",
"getStatsRows",
"(",
"boolean",
"interval",
",",
"final",
"Long",
"now",
")",
"{",
"this",
".",
"now",
"=",
"now",
";",
"/*\n * Synchronizing on this allows derived classes to maintain thread safety\n */",
"synchro... | Get the latest stat values as an array of arrays of objects suitable for
insertion into an VoltTable
@param interval Whether to get stats since the beginning or since the
last time stats were retrieved
@return Array of Arrays of objects containing the latest values | [
"Get",
"the",
"latest",
"stat",
"values",
"as",
"an",
"array",
"of",
"arrays",
"of",
"objects",
"suitable",
"for",
"insertion",
"into",
"an",
"VoltTable"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/StatsSource.java#L115-L131 | train |
VoltDB/voltdb | src/frontend/org/voltdb/StatsSource.java | StatsSource.updateStatsRow | protected void updateStatsRow(Object rowKey, Object rowValues[]) {
rowValues[0] = now;
rowValues[1] = m_hostId;
rowValues[2] = m_hostname;
} | java | protected void updateStatsRow(Object rowKey, Object rowValues[]) {
rowValues[0] = now;
rowValues[1] = m_hostId;
rowValues[2] = m_hostname;
} | [
"protected",
"void",
"updateStatsRow",
"(",
"Object",
"rowKey",
",",
"Object",
"rowValues",
"[",
"]",
")",
"{",
"rowValues",
"[",
"0",
"]",
"=",
"now",
";",
"rowValues",
"[",
"1",
"]",
"=",
"m_hostId",
";",
"rowValues",
"[",
"2",
"]",
"=",
"m_hostname"... | Update the parameter array with the latest values. This is similar to
populateColumnSchema in that it must be overriden by derived classes and
the derived class implementation must call the super classes
implementation.
@param rowKey Key identifying the specific row to be populated
@param rowValues Output parameter. Array of values to be updated. | [
"Update",
"the",
"parameter",
"array",
"with",
"the",
"latest",
"values",
".",
"This",
"is",
"similar",
"to",
"populateColumnSchema",
"in",
"that",
"it",
"must",
"be",
"overriden",
"by",
"derived",
"classes",
"and",
"the",
"derived",
"class",
"implementation",
... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/StatsSource.java#L183-L187 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/server/persistence/FileSnap.java | FileSnap.deserialize | @Override
public long deserialize(DataTree dt, Map<Long, Long> sessions)
throws IOException {
// we run through 100 snapshots (not all of them)
// if we cannot get it running within 100 snapshots
// we should give up
List<File> snapList = findNValidSnapshots(100);
if (snapList.size() == 0) {
return -1L;
}
File snap = null;
boolean foundValid = false;
for (int i = 0; i < snapList.size(); i++) {
snap = snapList.get(i);
InputStream snapIS = null;
CheckedInputStream crcIn = null;
try {
LOG.info("Reading snapshot " + snap);
snapIS = new BufferedInputStream(new FileInputStream(snap));
crcIn = new CheckedInputStream(snapIS, new Adler32());
InputArchive ia = BinaryInputArchive.getArchive(crcIn);
deserialize(dt,sessions, ia);
long checkSum = crcIn.getChecksum().getValue();
long val = ia.readLong("val");
if (val != checkSum) {
throw new IOException("CRC corruption in snapshot : " + snap);
}
foundValid = true;
break;
} catch(IOException e) {
LOG.warn("problem reading snap file " + snap, e);
} finally {
if (snapIS != null)
snapIS.close();
if (crcIn != null)
crcIn.close();
}
}
if (!foundValid) {
throw new IOException("Not able to find valid snapshots in " + snapDir);
}
dt.lastProcessedZxid = Util.getZxidFromName(snap.getName(), "snapshot");
return dt.lastProcessedZxid;
} | java | @Override
public long deserialize(DataTree dt, Map<Long, Long> sessions)
throws IOException {
// we run through 100 snapshots (not all of them)
// if we cannot get it running within 100 snapshots
// we should give up
List<File> snapList = findNValidSnapshots(100);
if (snapList.size() == 0) {
return -1L;
}
File snap = null;
boolean foundValid = false;
for (int i = 0; i < snapList.size(); i++) {
snap = snapList.get(i);
InputStream snapIS = null;
CheckedInputStream crcIn = null;
try {
LOG.info("Reading snapshot " + snap);
snapIS = new BufferedInputStream(new FileInputStream(snap));
crcIn = new CheckedInputStream(snapIS, new Adler32());
InputArchive ia = BinaryInputArchive.getArchive(crcIn);
deserialize(dt,sessions, ia);
long checkSum = crcIn.getChecksum().getValue();
long val = ia.readLong("val");
if (val != checkSum) {
throw new IOException("CRC corruption in snapshot : " + snap);
}
foundValid = true;
break;
} catch(IOException e) {
LOG.warn("problem reading snap file " + snap, e);
} finally {
if (snapIS != null)
snapIS.close();
if (crcIn != null)
crcIn.close();
}
}
if (!foundValid) {
throw new IOException("Not able to find valid snapshots in " + snapDir);
}
dt.lastProcessedZxid = Util.getZxidFromName(snap.getName(), "snapshot");
return dt.lastProcessedZxid;
} | [
"@",
"Override",
"public",
"long",
"deserialize",
"(",
"DataTree",
"dt",
",",
"Map",
"<",
"Long",
",",
"Long",
">",
"sessions",
")",
"throws",
"IOException",
"{",
"// we run through 100 snapshots (not all of them)",
"// if we cannot get it running within 100 snapshots",
"... | deserialize a data tree from the most recent snapshot
@return the zxid of the snapshot | [
"deserialize",
"a",
"data",
"tree",
"from",
"the",
"most",
"recent",
"snapshot"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/server/persistence/FileSnap.java#L70-L113 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/server/persistence/FileSnap.java | FileSnap.deserialize | public void deserialize(DataTree dt, Map<Long, Long> sessions,
InputArchive ia) throws IOException {
FileHeader header = new FileHeader();
header.deserialize(ia, "fileheader");
if (header.getMagic() != SNAP_MAGIC) {
throw new IOException("mismatching magic headers "
+ header.getMagic() +
" != " + FileSnap.SNAP_MAGIC);
}
SerializeUtils.deserializeSnapshot(dt,ia,sessions);
} | java | public void deserialize(DataTree dt, Map<Long, Long> sessions,
InputArchive ia) throws IOException {
FileHeader header = new FileHeader();
header.deserialize(ia, "fileheader");
if (header.getMagic() != SNAP_MAGIC) {
throw new IOException("mismatching magic headers "
+ header.getMagic() +
" != " + FileSnap.SNAP_MAGIC);
}
SerializeUtils.deserializeSnapshot(dt,ia,sessions);
} | [
"public",
"void",
"deserialize",
"(",
"DataTree",
"dt",
",",
"Map",
"<",
"Long",
",",
"Long",
">",
"sessions",
",",
"InputArchive",
"ia",
")",
"throws",
"IOException",
"{",
"FileHeader",
"header",
"=",
"new",
"FileHeader",
"(",
")",
";",
"header",
".",
"... | deserialize the datatree from an inputarchive
@param dt the datatree to be serialized into
@param sessions the sessions to be filled up
@param ia the input archive to restore from
@throws IOException | [
"deserialize",
"the",
"datatree",
"from",
"an",
"inputarchive"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/server/persistence/FileSnap.java#L122-L132 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/server/persistence/FileSnap.java | FileSnap.findMostRecentSnapshot | @Override
public File findMostRecentSnapshot() throws IOException {
List<File> files = findNValidSnapshots(1);
if (files.size() == 0) {
return null;
}
return files.get(0);
} | java | @Override
public File findMostRecentSnapshot() throws IOException {
List<File> files = findNValidSnapshots(1);
if (files.size() == 0) {
return null;
}
return files.get(0);
} | [
"@",
"Override",
"public",
"File",
"findMostRecentSnapshot",
"(",
")",
"throws",
"IOException",
"{",
"List",
"<",
"File",
">",
"files",
"=",
"findNValidSnapshots",
"(",
"1",
")",
";",
"if",
"(",
"files",
".",
"size",
"(",
")",
"==",
"0",
")",
"{",
"ret... | find the most recent snapshot in the database.
@return the file containing the most recent snapshot | [
"find",
"the",
"most",
"recent",
"snapshot",
"in",
"the",
"database",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/server/persistence/FileSnap.java#L138-L145 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/server/persistence/FileSnap.java | FileSnap.findNRecentSnapshots | public List<File> findNRecentSnapshots(int n) throws IOException {
List<File> files = Util.sortDataDir(snapDir.listFiles(), "snapshot", false);
int i = 0;
List<File> list = new ArrayList<File>();
for (File f: files) {
if (i==n)
break;
i++;
list.add(f);
}
return list;
} | java | public List<File> findNRecentSnapshots(int n) throws IOException {
List<File> files = Util.sortDataDir(snapDir.listFiles(), "snapshot", false);
int i = 0;
List<File> list = new ArrayList<File>();
for (File f: files) {
if (i==n)
break;
i++;
list.add(f);
}
return list;
} | [
"public",
"List",
"<",
"File",
">",
"findNRecentSnapshots",
"(",
"int",
"n",
")",
"throws",
"IOException",
"{",
"List",
"<",
"File",
">",
"files",
"=",
"Util",
".",
"sortDataDir",
"(",
"snapDir",
".",
"listFiles",
"(",
")",
",",
"\"snapshot\"",
",",
"fal... | find the last n snapshots. this does not have
any checks if the snapshot might be valid or not
@param the number of most recent snapshots
@return the last n snapshots
@throws IOException | [
"find",
"the",
"last",
"n",
"snapshots",
".",
"this",
"does",
"not",
"have",
"any",
"checks",
"if",
"the",
"snapshot",
"might",
"be",
"valid",
"or",
"not"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/server/persistence/FileSnap.java#L189-L200 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/server/persistence/FileSnap.java | FileSnap.serialize | protected void serialize(DataTree dt,Map<Long, Long> sessions,
OutputArchive oa, FileHeader header) throws IOException {
// this is really a programmatic error and not something that can
// happen at runtime
if(header==null)
throw new IllegalStateException(
"Snapshot's not open for writing: uninitialized header");
header.serialize(oa, "fileheader");
SerializeUtils.serializeSnapshot(dt,oa,sessions);
} | java | protected void serialize(DataTree dt,Map<Long, Long> sessions,
OutputArchive oa, FileHeader header) throws IOException {
// this is really a programmatic error and not something that can
// happen at runtime
if(header==null)
throw new IllegalStateException(
"Snapshot's not open for writing: uninitialized header");
header.serialize(oa, "fileheader");
SerializeUtils.serializeSnapshot(dt,oa,sessions);
} | [
"protected",
"void",
"serialize",
"(",
"DataTree",
"dt",
",",
"Map",
"<",
"Long",
",",
"Long",
">",
"sessions",
",",
"OutputArchive",
"oa",
",",
"FileHeader",
"header",
")",
"throws",
"IOException",
"{",
"// this is really a programmatic error and not something that c... | serialize the datatree and sessions
@param dt the datatree to be serialized
@param sessions the sessions to be serialized
@param oa the output archive to serialize into
@param header the header of this snapshot
@throws IOException | [
"serialize",
"the",
"datatree",
"and",
"sessions"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/server/persistence/FileSnap.java#L210-L219 | train |
VoltDB/voltdb | third_party/java/src/org/apache/zookeeper_voltpatches/server/persistence/FileSnap.java | FileSnap.serialize | @Override
public synchronized void serialize(DataTree dt, Map<Long, Long> sessions, File snapShot)
throws IOException {
if (!close) {
OutputStream sessOS = new BufferedOutputStream(new FileOutputStream(snapShot));
CheckedOutputStream crcOut = new CheckedOutputStream(sessOS, new Adler32());
//CheckedOutputStream cout = new CheckedOutputStream()
OutputArchive oa = BinaryOutputArchive.getArchive(crcOut);
FileHeader header = new FileHeader(SNAP_MAGIC, VERSION, dbId);
serialize(dt,sessions,oa, header);
long val = crcOut.getChecksum().getValue();
oa.writeLong(val, "val");
oa.writeString("/", "path");
sessOS.flush();
crcOut.close();
sessOS.close();
}
} | java | @Override
public synchronized void serialize(DataTree dt, Map<Long, Long> sessions, File snapShot)
throws IOException {
if (!close) {
OutputStream sessOS = new BufferedOutputStream(new FileOutputStream(snapShot));
CheckedOutputStream crcOut = new CheckedOutputStream(sessOS, new Adler32());
//CheckedOutputStream cout = new CheckedOutputStream()
OutputArchive oa = BinaryOutputArchive.getArchive(crcOut);
FileHeader header = new FileHeader(SNAP_MAGIC, VERSION, dbId);
serialize(dt,sessions,oa, header);
long val = crcOut.getChecksum().getValue();
oa.writeLong(val, "val");
oa.writeString("/", "path");
sessOS.flush();
crcOut.close();
sessOS.close();
}
} | [
"@",
"Override",
"public",
"synchronized",
"void",
"serialize",
"(",
"DataTree",
"dt",
",",
"Map",
"<",
"Long",
",",
"Long",
">",
"sessions",
",",
"File",
"snapShot",
")",
"throws",
"IOException",
"{",
"if",
"(",
"!",
"close",
")",
"{",
"OutputStream",
"... | serialize the datatree and session into the file snapshot
@param dt the datatree to be serialized
@param sessions the sessions to be serialized
@param snapShot the file to store snapshot into | [
"serialize",
"the",
"datatree",
"and",
"session",
"into",
"the",
"file",
"snapshot"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/third_party/java/src/org/apache/zookeeper_voltpatches/server/persistence/FileSnap.java#L227-L244 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/SystemStatsCollector.java | SystemStatsCollector.sampleSystemNow | public static Datum sampleSystemNow(final boolean medium, final boolean large) {
Datum d = generateCurrentSample();
if (d == null)
return null;
historyS.addLast(d);
if (historyS.size() > historySize) historyS.removeFirst();
if (medium) {
historyM.addLast(d);
if (historyM.size() > historySize) historyM.removeFirst();
}
if (large) {
historyL.addLast(d);
if (historyL.size() > historySize) historyL.removeFirst();
}
return d;
} | java | public static Datum sampleSystemNow(final boolean medium, final boolean large) {
Datum d = generateCurrentSample();
if (d == null)
return null;
historyS.addLast(d);
if (historyS.size() > historySize) historyS.removeFirst();
if (medium) {
historyM.addLast(d);
if (historyM.size() > historySize) historyM.removeFirst();
}
if (large) {
historyL.addLast(d);
if (historyL.size() > historySize) historyL.removeFirst();
}
return d;
} | [
"public",
"static",
"Datum",
"sampleSystemNow",
"(",
"final",
"boolean",
"medium",
",",
"final",
"boolean",
"large",
")",
"{",
"Datum",
"d",
"=",
"generateCurrentSample",
"(",
")",
";",
"if",
"(",
"d",
"==",
"null",
")",
"return",
"null",
";",
"historyS",
... | Synchronously collect memory stats.
@param medium Add result to medium set?
@param large Add result to large set?
@return The generated Datum instance. | [
"Synchronously",
"collect",
"memory",
"stats",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/SystemStatsCollector.java#L237-L253 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/SystemStatsCollector.java | SystemStatsCollector.asyncSampleSystemNow | public static synchronized void asyncSampleSystemNow(final boolean medium, final boolean large) {
// slow mode starts an async thread
if (mode == GetRSSMode.PS) {
if (thread != null) {
if (thread.isAlive()) return;
else thread = null;
}
thread = new Thread(new Runnable() {
@Override
public void run() { sampleSystemNow(medium, large); }
});
thread.start();
}
// fast mode doesn't spawn a thread
else {
sampleSystemNow(medium, large);
}
} | java | public static synchronized void asyncSampleSystemNow(final boolean medium, final boolean large) {
// slow mode starts an async thread
if (mode == GetRSSMode.PS) {
if (thread != null) {
if (thread.isAlive()) return;
else thread = null;
}
thread = new Thread(new Runnable() {
@Override
public void run() { sampleSystemNow(medium, large); }
});
thread.start();
}
// fast mode doesn't spawn a thread
else {
sampleSystemNow(medium, large);
}
} | [
"public",
"static",
"synchronized",
"void",
"asyncSampleSystemNow",
"(",
"final",
"boolean",
"medium",
",",
"final",
"boolean",
"large",
")",
"{",
"// slow mode starts an async thread",
"if",
"(",
"mode",
"==",
"GetRSSMode",
".",
"PS",
")",
"{",
"if",
"(",
"thre... | Fire off a thread to asynchronously collect stats.
@param medium Add result to medium set?
@param large Add result to large set? | [
"Fire",
"off",
"a",
"thread",
"to",
"asynchronously",
"collect",
"stats",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/SystemStatsCollector.java#L260-L278 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/SystemStatsCollector.java | SystemStatsCollector.initialize | private static synchronized void initialize() {
PlatformProperties pp = PlatformProperties.getPlatformProperties();
String processName = java.lang.management.ManagementFactory.getRuntimeMXBean().getName();
String pidString = processName.substring(0, processName.indexOf('@'));
pid = Integer.valueOf(pidString);
initialized = true;
// get the RSS and other stats from scraping "ps" from the command line
PSScraper.PSData psdata = PSScraper.getPSData(pid);
assert(psdata.rss > 0);
// figure out how much memory this thing has
memorysize = pp.ramInMegabytes;
assert(memorysize > 0);
// now try to figure out the best way to get the rss size
long rss = -1;
// try the mac method
try {
rss = ExecutionEngine.nativeGetRSS();
}
// This catch is broad to specifically include the UnsatisfiedLinkError that arises when
// using the hsqldb backend on linux -- along with any other exceptions that might arise.
// Otherwise, the hsql backend would get an annoying report to stdout
// as the useless stats thread got needlessly killed.
catch (Throwable e) { }
if (rss > 0) mode = GetRSSMode.MACOSX_NATIVE;
// try procfs
rss = getRSSFromProcFS();
if (rss > 0) mode = GetRSSMode.PROCFS;
// notify users if stats collection might be slow
if (mode == GetRSSMode.PS) {
VoltLogger logger = new VoltLogger("HOST");
logger.warn("System statistics will be collected in a sub-optimal "
+ "manner because either procfs couldn't be read from or "
+ "the native library couldn't be loaded.");
}
} | java | private static synchronized void initialize() {
PlatformProperties pp = PlatformProperties.getPlatformProperties();
String processName = java.lang.management.ManagementFactory.getRuntimeMXBean().getName();
String pidString = processName.substring(0, processName.indexOf('@'));
pid = Integer.valueOf(pidString);
initialized = true;
// get the RSS and other stats from scraping "ps" from the command line
PSScraper.PSData psdata = PSScraper.getPSData(pid);
assert(psdata.rss > 0);
// figure out how much memory this thing has
memorysize = pp.ramInMegabytes;
assert(memorysize > 0);
// now try to figure out the best way to get the rss size
long rss = -1;
// try the mac method
try {
rss = ExecutionEngine.nativeGetRSS();
}
// This catch is broad to specifically include the UnsatisfiedLinkError that arises when
// using the hsqldb backend on linux -- along with any other exceptions that might arise.
// Otherwise, the hsql backend would get an annoying report to stdout
// as the useless stats thread got needlessly killed.
catch (Throwable e) { }
if (rss > 0) mode = GetRSSMode.MACOSX_NATIVE;
// try procfs
rss = getRSSFromProcFS();
if (rss > 0) mode = GetRSSMode.PROCFS;
// notify users if stats collection might be slow
if (mode == GetRSSMode.PS) {
VoltLogger logger = new VoltLogger("HOST");
logger.warn("System statistics will be collected in a sub-optimal "
+ "manner because either procfs couldn't be read from or "
+ "the native library couldn't be loaded.");
}
} | [
"private",
"static",
"synchronized",
"void",
"initialize",
"(",
")",
"{",
"PlatformProperties",
"pp",
"=",
"PlatformProperties",
".",
"getPlatformProperties",
"(",
")",
";",
"String",
"processName",
"=",
"java",
".",
"lang",
".",
"management",
".",
"ManagementFact... | Get the process id, the total memory size and determine the
best way to get the RSS on an ongoing basis. | [
"Get",
"the",
"process",
"id",
"the",
"total",
"memory",
"size",
"and",
"determine",
"the",
"best",
"way",
"to",
"get",
"the",
"RSS",
"on",
"an",
"ongoing",
"basis",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/SystemStatsCollector.java#L294-L335 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/SystemStatsCollector.java | SystemStatsCollector.getRSSFromProcFS | private static long getRSSFromProcFS() {
try {
File statFile = new File(String.format("/proc/%d/stat", pid));
FileInputStream fis = new FileInputStream(statFile);
try {
BufferedReader r = new BufferedReader(new InputStreamReader(fis));
String stats = r.readLine();
String[] parts = stats.split(" ");
return Long.parseLong(parts[23]) * 4 * 1024;
} finally {
fis.close();
}
}
catch (Exception e) {
return -1;
}
} | java | private static long getRSSFromProcFS() {
try {
File statFile = new File(String.format("/proc/%d/stat", pid));
FileInputStream fis = new FileInputStream(statFile);
try {
BufferedReader r = new BufferedReader(new InputStreamReader(fis));
String stats = r.readLine();
String[] parts = stats.split(" ");
return Long.parseLong(parts[23]) * 4 * 1024;
} finally {
fis.close();
}
}
catch (Exception e) {
return -1;
}
} | [
"private",
"static",
"long",
"getRSSFromProcFS",
"(",
")",
"{",
"try",
"{",
"File",
"statFile",
"=",
"new",
"File",
"(",
"String",
".",
"format",
"(",
"\"/proc/%d/stat\"",
",",
"pid",
")",
")",
";",
"FileInputStream",
"fis",
"=",
"new",
"FileInputStream",
... | Get the RSS using the procfs. If procfs is not
around, this will return -1; | [
"Get",
"the",
"RSS",
"using",
"the",
"procfs",
".",
"If",
"procfs",
"is",
"not",
"around",
"this",
"will",
"return",
"-",
"1",
";"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/SystemStatsCollector.java#L341-L357 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/SystemStatsCollector.java | SystemStatsCollector.generateCurrentSample | private static synchronized Datum generateCurrentSample() {
// Code used to fake system statistics by tests
if (testStatsProducer!=null) {
return testStatsProducer.getCurrentStatsData();
}
// get this info once
if (!initialized) initialize();
long rss = -1;
switch (mode) {
case MACOSX_NATIVE:
rss = ExecutionEngine.nativeGetRSS();
break;
case PROCFS:
rss = getRSSFromProcFS();
break;
case PS:
rss = PSScraper.getPSData(pid).rss;
break;
}
// create a new Datum which adds java stats
Datum d = new Datum(rss);
return d;
} | java | private static synchronized Datum generateCurrentSample() {
// Code used to fake system statistics by tests
if (testStatsProducer!=null) {
return testStatsProducer.getCurrentStatsData();
}
// get this info once
if (!initialized) initialize();
long rss = -1;
switch (mode) {
case MACOSX_NATIVE:
rss = ExecutionEngine.nativeGetRSS();
break;
case PROCFS:
rss = getRSSFromProcFS();
break;
case PS:
rss = PSScraper.getPSData(pid).rss;
break;
}
// create a new Datum which adds java stats
Datum d = new Datum(rss);
return d;
} | [
"private",
"static",
"synchronized",
"Datum",
"generateCurrentSample",
"(",
")",
"{",
"// Code used to fake system statistics by tests",
"if",
"(",
"testStatsProducer",
"!=",
"null",
")",
"{",
"return",
"testStatsProducer",
".",
"getCurrentStatsData",
"(",
")",
";",
"}"... | Poll the operating system and generate a Datum
@return A newly created Datum instance. | [
"Poll",
"the",
"operating",
"system",
"and",
"generate",
"a",
"Datum"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/SystemStatsCollector.java#L368-L393 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/SystemStatsCollector.java | SystemStatsCollector.getGoogleChartURL | public static synchronized String getGoogleChartURL(int minutes, int width, int height, String timeLabel) {
ArrayDeque<Datum> history = historyS;
if (minutes > 2) history = historyM;
if (minutes > 30) history = historyL;
HTMLChartHelper chart = new HTMLChartHelper();
chart.width = width;
chart.height = height;
chart.timeLabel = timeLabel;
HTMLChartHelper.DataSet Jds = new HTMLChartHelper.DataSet();
chart.data.add(Jds);
Jds.title = "UsedJava";
Jds.belowcolor = "ff9999";
HTMLChartHelper.DataSet Rds = new HTMLChartHelper.DataSet();
chart.data.add(Rds);
Rds.title = "RSS";
Rds.belowcolor = "ff0000";
HTMLChartHelper.DataSet RUds = new HTMLChartHelper.DataSet();
chart.data.add(RUds);
RUds.title = "RSS+UnusedJava";
RUds.dashlength = 6;
RUds.spacelength = 3;
RUds.thickness = 2;
RUds.belowcolor = "ffffff";
long cropts = System.currentTimeMillis();
cropts -= (60 * 1000 * minutes);
long modulo = (60 * 1000 * minutes) / 30;
double maxmemdatum = 0;
for (Datum d : history) {
if (d.timestamp < cropts) continue;
double javaused = d.javausedheapmem + d.javausedsysmem;
double javaunused = SystemStatsCollector.javamaxheapmem - d.javausedheapmem;
javaused /= 1204 * 1024;
javaunused /= 1204 * 1024;
double rss = d.rss / 1024 / 1024;
long ts = (d.timestamp / modulo) * modulo;
if ((rss + javaunused) > maxmemdatum)
maxmemdatum = rss + javaunused;
RUds.append(ts, rss + javaunused);
Rds.append(ts, rss);
Jds.append(ts, javaused);
}
chart.megsMax = 2;
while (chart.megsMax < maxmemdatum)
chart.megsMax *= 2;
return chart.getURL(minutes);
} | java | public static synchronized String getGoogleChartURL(int minutes, int width, int height, String timeLabel) {
ArrayDeque<Datum> history = historyS;
if (minutes > 2) history = historyM;
if (minutes > 30) history = historyL;
HTMLChartHelper chart = new HTMLChartHelper();
chart.width = width;
chart.height = height;
chart.timeLabel = timeLabel;
HTMLChartHelper.DataSet Jds = new HTMLChartHelper.DataSet();
chart.data.add(Jds);
Jds.title = "UsedJava";
Jds.belowcolor = "ff9999";
HTMLChartHelper.DataSet Rds = new HTMLChartHelper.DataSet();
chart.data.add(Rds);
Rds.title = "RSS";
Rds.belowcolor = "ff0000";
HTMLChartHelper.DataSet RUds = new HTMLChartHelper.DataSet();
chart.data.add(RUds);
RUds.title = "RSS+UnusedJava";
RUds.dashlength = 6;
RUds.spacelength = 3;
RUds.thickness = 2;
RUds.belowcolor = "ffffff";
long cropts = System.currentTimeMillis();
cropts -= (60 * 1000 * minutes);
long modulo = (60 * 1000 * minutes) / 30;
double maxmemdatum = 0;
for (Datum d : history) {
if (d.timestamp < cropts) continue;
double javaused = d.javausedheapmem + d.javausedsysmem;
double javaunused = SystemStatsCollector.javamaxheapmem - d.javausedheapmem;
javaused /= 1204 * 1024;
javaunused /= 1204 * 1024;
double rss = d.rss / 1024 / 1024;
long ts = (d.timestamp / modulo) * modulo;
if ((rss + javaunused) > maxmemdatum)
maxmemdatum = rss + javaunused;
RUds.append(ts, rss + javaunused);
Rds.append(ts, rss);
Jds.append(ts, javaused);
}
chart.megsMax = 2;
while (chart.megsMax < maxmemdatum)
chart.megsMax *= 2;
return chart.getURL(minutes);
} | [
"public",
"static",
"synchronized",
"String",
"getGoogleChartURL",
"(",
"int",
"minutes",
",",
"int",
"width",
",",
"int",
"height",
",",
"String",
"timeLabel",
")",
"{",
"ArrayDeque",
"<",
"Datum",
">",
"history",
"=",
"historyS",
";",
"if",
"(",
"minutes",... | Get a URL that uses the Google Charts API to show a chart of memory usage history.
@param minutes The number of minutes the chart should cover. Tested values are 2, 30 and 1440.
@param width The width of the chart image in pixels.
@param height The height of the chart image in pixels.
@param timeLabel The text to put under the left end of the x axis.
@return A String containing the URL of the chart. | [
"Get",
"a",
"URL",
"that",
"uses",
"the",
"Google",
"Charts",
"API",
"to",
"show",
"a",
"chart",
"of",
"memory",
"usage",
"history",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/SystemStatsCollector.java#L404-L463 | train |
VoltDB/voltdb | src/frontend/org/voltdb/utils/SystemStatsCollector.java | SystemStatsCollector.main | public static void main(String[] args) {
int repeat = 1000;
long start, duration, correct;
double per;
String processName = java.lang.management.ManagementFactory.getRuntimeMXBean().getName();
String pidString = processName.substring(0, processName.indexOf('@'));
pid = Integer.valueOf(pidString);
// ETHAN (11/7/2018): If loading the native library does not have to succeed, why load?
// org.voltdb.NativeLibraryLoader.loadVoltDB(false);
// test the default fallback performance
start = System.currentTimeMillis();
correct = 0;
for (int i = 0; i < repeat; i++) {
long rss = PSScraper.getPSData(pid).rss;
if (rss > 0) correct++;
}
duration = System.currentTimeMillis() - start;
per = duration / (double) repeat;
System.out.printf("%.2f ms per \"ps\" call / %d / %d correct\n",
per, correct, repeat);
// test linux procfs performance
start = System.currentTimeMillis();
correct = 0;
for (int i = 0; i < repeat; i++) {
long rss = getRSSFromProcFS();
if (rss > 0) correct++;
}
duration = System.currentTimeMillis() - start;
per = duration / (double) repeat;
System.out.printf("%.2f ms per procfs read / %d / %d correct\n",
per, correct, repeat);
// test mac performance
start = System.currentTimeMillis();
correct = 0;
for (int i = 0; i < repeat; i++) {
long rss = ExecutionEngine.nativeGetRSS();
if (rss > 0) correct++;
}
duration = System.currentTimeMillis() - start;
per = duration / (double) repeat;
System.out.printf("%.2f ms per ee.nativeGetRSS call / %d / %d correct\n",
per, correct, repeat);
} | java | public static void main(String[] args) {
int repeat = 1000;
long start, duration, correct;
double per;
String processName = java.lang.management.ManagementFactory.getRuntimeMXBean().getName();
String pidString = processName.substring(0, processName.indexOf('@'));
pid = Integer.valueOf(pidString);
// ETHAN (11/7/2018): If loading the native library does not have to succeed, why load?
// org.voltdb.NativeLibraryLoader.loadVoltDB(false);
// test the default fallback performance
start = System.currentTimeMillis();
correct = 0;
for (int i = 0; i < repeat; i++) {
long rss = PSScraper.getPSData(pid).rss;
if (rss > 0) correct++;
}
duration = System.currentTimeMillis() - start;
per = duration / (double) repeat;
System.out.printf("%.2f ms per \"ps\" call / %d / %d correct\n",
per, correct, repeat);
// test linux procfs performance
start = System.currentTimeMillis();
correct = 0;
for (int i = 0; i < repeat; i++) {
long rss = getRSSFromProcFS();
if (rss > 0) correct++;
}
duration = System.currentTimeMillis() - start;
per = duration / (double) repeat;
System.out.printf("%.2f ms per procfs read / %d / %d correct\n",
per, correct, repeat);
// test mac performance
start = System.currentTimeMillis();
correct = 0;
for (int i = 0; i < repeat; i++) {
long rss = ExecutionEngine.nativeGetRSS();
if (rss > 0) correct++;
}
duration = System.currentTimeMillis() - start;
per = duration / (double) repeat;
System.out.printf("%.2f ms per ee.nativeGetRSS call / %d / %d correct\n",
per, correct, repeat);
} | [
"public",
"static",
"void",
"main",
"(",
"String",
"[",
"]",
"args",
")",
"{",
"int",
"repeat",
"=",
"1000",
";",
"long",
"start",
",",
"duration",
",",
"correct",
";",
"double",
"per",
";",
"String",
"processName",
"=",
"java",
".",
"lang",
".",
"ma... | Manual performance testing code for getting stats. | [
"Manual",
"performance",
"testing",
"code",
"for",
"getting",
"stats",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/utils/SystemStatsCollector.java#L472-L519 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/TransactionManager.java | TransactionManager.rollbackPartial | void rollbackPartial(Session session, int start, long timestamp) {
Object[] list = session.rowActionList.getArray();
int limit = session.rowActionList.size();
if (start == limit) {
return;
}
for (int i = start; i < limit; i++) {
RowAction action = (RowAction) list[i];
if (action != null) {
action.rollback(session, timestamp);
} else {
System.out.println("null action in rollback " + start);
}
}
// rolled back transactions can always be merged as they have never been
// seen by other sessions
mergeRolledBackTransaction(session.rowActionList.getArray(), start,
limit);
rowActionMapRemoveTransaction(session.rowActionList.getArray(), start,
limit, false);
session.rowActionList.setSize(start);
} | java | void rollbackPartial(Session session, int start, long timestamp) {
Object[] list = session.rowActionList.getArray();
int limit = session.rowActionList.size();
if (start == limit) {
return;
}
for (int i = start; i < limit; i++) {
RowAction action = (RowAction) list[i];
if (action != null) {
action.rollback(session, timestamp);
} else {
System.out.println("null action in rollback " + start);
}
}
// rolled back transactions can always be merged as they have never been
// seen by other sessions
mergeRolledBackTransaction(session.rowActionList.getArray(), start,
limit);
rowActionMapRemoveTransaction(session.rowActionList.getArray(), start,
limit, false);
session.rowActionList.setSize(start);
} | [
"void",
"rollbackPartial",
"(",
"Session",
"session",
",",
"int",
"start",
",",
"long",
"timestamp",
")",
"{",
"Object",
"[",
"]",
"list",
"=",
"session",
".",
"rowActionList",
".",
"getArray",
"(",
")",
";",
"int",
"limit",
"=",
"session",
".",
"rowActi... | rollback the row actions from start index in list and
the given timestamp | [
"rollback",
"the",
"row",
"actions",
"from",
"start",
"index",
"in",
"list",
"and",
"the",
"given",
"timestamp"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/TransactionManager.java#L436-L462 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/TransactionManager.java | TransactionManager.canRead | public boolean canRead(Session session, Row row) {
synchronized (row) {
RowAction action = row.rowAction;
if (action == null) {
return true;
}
return action.canRead(session);
}
} | java | public boolean canRead(Session session, Row row) {
synchronized (row) {
RowAction action = row.rowAction;
if (action == null) {
return true;
}
return action.canRead(session);
}
} | [
"public",
"boolean",
"canRead",
"(",
"Session",
"session",
",",
"Row",
"row",
")",
"{",
"synchronized",
"(",
"row",
")",
"{",
"RowAction",
"action",
"=",
"row",
".",
"rowAction",
";",
"if",
"(",
"action",
"==",
"null",
")",
"{",
"return",
"true",
";",
... | functional unit - accessibility of rows | [
"functional",
"unit",
"-",
"accessibility",
"of",
"rows"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/TransactionManager.java#L517-L528 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/TransactionManager.java | TransactionManager.setTransactionInfo | public void setTransactionInfo(CachedObject object) {
Row row = (Row) object;
if (row.rowAction != null) {
return;
}
RowAction rowact = (RowAction) rowActionMap.get(row.position);
row.rowAction = rowact;
} | java | public void setTransactionInfo(CachedObject object) {
Row row = (Row) object;
if (row.rowAction != null) {
return;
}
RowAction rowact = (RowAction) rowActionMap.get(row.position);
row.rowAction = rowact;
} | [
"public",
"void",
"setTransactionInfo",
"(",
"CachedObject",
"object",
")",
"{",
"Row",
"row",
"=",
"(",
"Row",
")",
"object",
";",
"if",
"(",
"row",
".",
"rowAction",
"!=",
"null",
")",
"{",
"return",
";",
"}",
"RowAction",
"rowact",
"=",
"(",
"RowAct... | add transaction info to a row just loaded from the cache. called only
for CACHED tables | [
"add",
"transaction",
"info",
"to",
"a",
"row",
"just",
"loaded",
"from",
"the",
"cache",
".",
"called",
"only",
"for",
"CACHED",
"tables"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/TransactionManager.java#L609-L620 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/TransactionManager.java | TransactionManager.mergeRolledBackTransaction | void mergeRolledBackTransaction(Object[] list, int start, int limit) {
for (int i = start; i < limit; i++) {
RowAction rowact = (RowAction) list[i];
if (rowact == null || rowact.type == RowActionBase.ACTION_NONE
|| rowact.type == RowActionBase.ACTION_DELETE_FINAL) {
continue;
}
Row row = rowact.memoryRow;
if (row == null) {
PersistentStore store =
rowact.session.sessionData.getRowStore(rowact.table);
row = (Row) store.get(rowact.getPos(), false);
}
if (row == null) {
continue;
}
synchronized (row) {
rowact.mergeRollback(row);
}
}
// } catch (Throwable t) {
// System.out.println("throw in merge");
// t.printStackTrace();
// }
} | java | void mergeRolledBackTransaction(Object[] list, int start, int limit) {
for (int i = start; i < limit; i++) {
RowAction rowact = (RowAction) list[i];
if (rowact == null || rowact.type == RowActionBase.ACTION_NONE
|| rowact.type == RowActionBase.ACTION_DELETE_FINAL) {
continue;
}
Row row = rowact.memoryRow;
if (row == null) {
PersistentStore store =
rowact.session.sessionData.getRowStore(rowact.table);
row = (Row) store.get(rowact.getPos(), false);
}
if (row == null) {
continue;
}
synchronized (row) {
rowact.mergeRollback(row);
}
}
// } catch (Throwable t) {
// System.out.println("throw in merge");
// t.printStackTrace();
// }
} | [
"void",
"mergeRolledBackTransaction",
"(",
"Object",
"[",
"]",
"list",
",",
"int",
"start",
",",
"int",
"limit",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"start",
";",
"i",
"<",
"limit",
";",
"i",
"++",
")",
"{",
"RowAction",
"rowact",
"=",
"(",
"Row... | merge a given list of transaction rollback action with given timestamp | [
"merge",
"a",
"given",
"list",
"of",
"transaction",
"rollback",
"action",
"with",
"given",
"timestamp"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/TransactionManager.java#L625-L657 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/TransactionManager.java | TransactionManager.addToCommittedQueue | void addToCommittedQueue(Session session, Object[] list) {
synchronized (committedTransactionTimestamps) {
// add the txList according to commit timestamp
committedTransactions.addLast(list);
// get session commit timestamp
committedTransactionTimestamps.addLast(session.actionTimestamp);
/* debug 190
if (committedTransactions.size() > 64) {
System.out.println("******* excessive transaction queue");
}
// debug 190 */
}
} | java | void addToCommittedQueue(Session session, Object[] list) {
synchronized (committedTransactionTimestamps) {
// add the txList according to commit timestamp
committedTransactions.addLast(list);
// get session commit timestamp
committedTransactionTimestamps.addLast(session.actionTimestamp);
/* debug 190
if (committedTransactions.size() > 64) {
System.out.println("******* excessive transaction queue");
}
// debug 190 */
}
} | [
"void",
"addToCommittedQueue",
"(",
"Session",
"session",
",",
"Object",
"[",
"]",
"list",
")",
"{",
"synchronized",
"(",
"committedTransactionTimestamps",
")",
"{",
"// add the txList according to commit timestamp",
"committedTransactions",
".",
"addLast",
"(",
"list",
... | add a list of actions to the end of queue | [
"add",
"a",
"list",
"of",
"actions",
"to",
"the",
"end",
"of",
"queue"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/TransactionManager.java#L662-L677 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/TransactionManager.java | TransactionManager.mergeExpiredTransactions | void mergeExpiredTransactions(Session session) {
long timestamp = getFirstLiveTransactionTimestamp();
while (true) {
long commitTimestamp = 0;
Object[] actions = null;
synchronized (committedTransactionTimestamps) {
if (committedTransactionTimestamps.isEmpty()) {
break;
}
commitTimestamp = committedTransactionTimestamps.getFirst();
if (commitTimestamp < timestamp) {
committedTransactionTimestamps.removeFirst();
actions = (Object[]) committedTransactions.removeFirst();
} else {
break;
}
}
mergeTransaction(session, actions, 0, actions.length,
commitTimestamp);
rowActionMapRemoveTransaction(actions, 0, actions.length, true);
}
} | java | void mergeExpiredTransactions(Session session) {
long timestamp = getFirstLiveTransactionTimestamp();
while (true) {
long commitTimestamp = 0;
Object[] actions = null;
synchronized (committedTransactionTimestamps) {
if (committedTransactionTimestamps.isEmpty()) {
break;
}
commitTimestamp = committedTransactionTimestamps.getFirst();
if (commitTimestamp < timestamp) {
committedTransactionTimestamps.removeFirst();
actions = (Object[]) committedTransactions.removeFirst();
} else {
break;
}
}
mergeTransaction(session, actions, 0, actions.length,
commitTimestamp);
rowActionMapRemoveTransaction(actions, 0, actions.length, true);
}
} | [
"void",
"mergeExpiredTransactions",
"(",
"Session",
"session",
")",
"{",
"long",
"timestamp",
"=",
"getFirstLiveTransactionTimestamp",
"(",
")",
";",
"while",
"(",
"true",
")",
"{",
"long",
"commitTimestamp",
"=",
"0",
";",
"Object",
"[",
"]",
"actions",
"=",
... | expire all committed transactions that are no longer in scope | [
"expire",
"all",
"committed",
"transactions",
"that",
"are",
"no",
"longer",
"in",
"scope"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/TransactionManager.java#L682-L710 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/TransactionManager.java | TransactionManager.endTransaction | void endTransaction(Session session) {
try {
writeLock.lock();
long timestamp = session.transactionTimestamp;
synchronized (liveTransactionTimestamps) {
session.isTransaction = false;
int index = liveTransactionTimestamps.indexOf(timestamp);
liveTransactionTimestamps.remove(index);
}
mergeExpiredTransactions(session);
} finally {
writeLock.unlock();
}
} | java | void endTransaction(Session session) {
try {
writeLock.lock();
long timestamp = session.transactionTimestamp;
synchronized (liveTransactionTimestamps) {
session.isTransaction = false;
int index = liveTransactionTimestamps.indexOf(timestamp);
liveTransactionTimestamps.remove(index);
}
mergeExpiredTransactions(session);
} finally {
writeLock.unlock();
}
} | [
"void",
"endTransaction",
"(",
"Session",
"session",
")",
"{",
"try",
"{",
"writeLock",
".",
"lock",
"(",
")",
";",
"long",
"timestamp",
"=",
"session",
".",
"transactionTimestamp",
";",
"synchronized",
"(",
"liveTransactionTimestamps",
")",
"{",
"session",
".... | remove session from queue when a transaction ends
and expire any committed transactions
that are no longer required. remove transactions ended before the first
timestamp in liveTransactionsSession queue | [
"remove",
"session",
"from",
"queue",
"when",
"a",
"transaction",
"ends",
"and",
"expire",
"any",
"committed",
"transactions",
"that",
"are",
"no",
"longer",
"required",
".",
"remove",
"transactions",
"ended",
"before",
"the",
"first",
"timestamp",
"in",
"liveTr... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/TransactionManager.java#L1060-L1079 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/TransactionManager.java | TransactionManager.getRowActionList | RowAction[] getRowActionList() {
try {
writeLock.lock();
Session[] sessions = database.sessionManager.getAllSessions();
int[] tIndex = new int[sessions.length];
RowAction[] rowActions;
int rowActionCount = 0;
{
int actioncount = 0;
for (int i = 0; i < sessions.length; i++) {
actioncount += sessions[i].getTransactionSize();
}
rowActions = new RowAction[actioncount];
}
while (true) {
boolean found = false;
long minChangeNo = Long.MAX_VALUE;
int sessionIndex = 0;
// find the lowest available SCN across all sessions
for (int i = 0; i < sessions.length; i++) {
int tSize = sessions[i].getTransactionSize();
if (tIndex[i] < tSize) {
RowAction current =
(RowAction) sessions[i].rowActionList.get(
tIndex[i]);
if (current.actionTimestamp < minChangeNo) {
minChangeNo = current.actionTimestamp;
sessionIndex = i;
}
found = true;
}
}
if (!found) {
break;
}
HsqlArrayList currentList =
sessions[sessionIndex].rowActionList;
for (; tIndex[sessionIndex] < currentList.size(); ) {
RowAction current =
(RowAction) currentList.get(tIndex[sessionIndex]);
// if the next change no is in this session, continue adding
if (current.actionTimestamp == minChangeNo + 1) {
minChangeNo++;
}
if (current.actionTimestamp == minChangeNo) {
rowActions[rowActionCount++] = current;
tIndex[sessionIndex]++;
} else {
break;
}
}
}
return rowActions;
} finally {
writeLock.unlock();
}
} | java | RowAction[] getRowActionList() {
try {
writeLock.lock();
Session[] sessions = database.sessionManager.getAllSessions();
int[] tIndex = new int[sessions.length];
RowAction[] rowActions;
int rowActionCount = 0;
{
int actioncount = 0;
for (int i = 0; i < sessions.length; i++) {
actioncount += sessions[i].getTransactionSize();
}
rowActions = new RowAction[actioncount];
}
while (true) {
boolean found = false;
long minChangeNo = Long.MAX_VALUE;
int sessionIndex = 0;
// find the lowest available SCN across all sessions
for (int i = 0; i < sessions.length; i++) {
int tSize = sessions[i].getTransactionSize();
if (tIndex[i] < tSize) {
RowAction current =
(RowAction) sessions[i].rowActionList.get(
tIndex[i]);
if (current.actionTimestamp < minChangeNo) {
minChangeNo = current.actionTimestamp;
sessionIndex = i;
}
found = true;
}
}
if (!found) {
break;
}
HsqlArrayList currentList =
sessions[sessionIndex].rowActionList;
for (; tIndex[sessionIndex] < currentList.size(); ) {
RowAction current =
(RowAction) currentList.get(tIndex[sessionIndex]);
// if the next change no is in this session, continue adding
if (current.actionTimestamp == minChangeNo + 1) {
minChangeNo++;
}
if (current.actionTimestamp == minChangeNo) {
rowActions[rowActionCount++] = current;
tIndex[sessionIndex]++;
} else {
break;
}
}
}
return rowActions;
} finally {
writeLock.unlock();
}
} | [
"RowAction",
"[",
"]",
"getRowActionList",
"(",
")",
"{",
"try",
"{",
"writeLock",
".",
"lock",
"(",
")",
";",
"Session",
"[",
"]",
"sessions",
"=",
"database",
".",
"sessionManager",
".",
"getAllSessions",
"(",
")",
";",
"int",
"[",
"]",
"tIndex",
"="... | Return an array of all row actions sorted by System Change No. | [
"Return",
"an",
"array",
"of",
"all",
"row",
"actions",
"sorted",
"by",
"System",
"Change",
"No",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/TransactionManager.java#L1097-L1170 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/TransactionManager.java | TransactionManager.getTransactionIDList | public DoubleIntIndex getTransactionIDList() {
writeLock.lock();
try {
DoubleIntIndex lookup = new DoubleIntIndex(10, false);
lookup.setKeysSearchTarget();
Iterator it = this.rowActionMap.keySet().iterator();
for (; it.hasNext(); ) {
lookup.addUnique(it.nextInt(), 0);
}
return lookup;
} finally {
writeLock.unlock();
}
} | java | public DoubleIntIndex getTransactionIDList() {
writeLock.lock();
try {
DoubleIntIndex lookup = new DoubleIntIndex(10, false);
lookup.setKeysSearchTarget();
Iterator it = this.rowActionMap.keySet().iterator();
for (; it.hasNext(); ) {
lookup.addUnique(it.nextInt(), 0);
}
return lookup;
} finally {
writeLock.unlock();
}
} | [
"public",
"DoubleIntIndex",
"getTransactionIDList",
"(",
")",
"{",
"writeLock",
".",
"lock",
"(",
")",
";",
"try",
"{",
"DoubleIntIndex",
"lookup",
"=",
"new",
"DoubleIntIndex",
"(",
"10",
",",
"false",
")",
";",
"lookup",
".",
"setKeysSearchTarget",
"(",
")... | Return a lookup of all row ids for cached tables in transactions.
For auto-defrag, as currently there will be no RowAction entries
at the time of defrag. | [
"Return",
"a",
"lookup",
"of",
"all",
"row",
"ids",
"for",
"cached",
"tables",
"in",
"transactions",
".",
"For",
"auto",
"-",
"defrag",
"as",
"currently",
"there",
"will",
"be",
"no",
"RowAction",
"entries",
"at",
"the",
"time",
"of",
"defrag",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/TransactionManager.java#L1177-L1196 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/TransactionManager.java | TransactionManager.convertTransactionIDs | public void convertTransactionIDs(DoubleIntIndex lookup) {
writeLock.lock();
try {
RowAction[] list = new RowAction[rowActionMap.size()];
Iterator it = this.rowActionMap.values().iterator();
for (int i = 0; it.hasNext(); i++) {
list[i] = (RowAction) it.next();
}
rowActionMap.clear();
for (int i = 0; i < list.length; i++) {
int pos = lookup.lookupFirstEqual(list[i].getPos());
list[i].setPos(pos);
rowActionMap.put(pos, list[i]);
}
} finally {
writeLock.unlock();
}
} | java | public void convertTransactionIDs(DoubleIntIndex lookup) {
writeLock.lock();
try {
RowAction[] list = new RowAction[rowActionMap.size()];
Iterator it = this.rowActionMap.values().iterator();
for (int i = 0; it.hasNext(); i++) {
list[i] = (RowAction) it.next();
}
rowActionMap.clear();
for (int i = 0; i < list.length; i++) {
int pos = lookup.lookupFirstEqual(list[i].getPos());
list[i].setPos(pos);
rowActionMap.put(pos, list[i]);
}
} finally {
writeLock.unlock();
}
} | [
"public",
"void",
"convertTransactionIDs",
"(",
"DoubleIntIndex",
"lookup",
")",
"{",
"writeLock",
".",
"lock",
"(",
")",
";",
"try",
"{",
"RowAction",
"[",
"]",
"list",
"=",
"new",
"RowAction",
"[",
"rowActionMap",
".",
"size",
"(",
")",
"]",
";",
"Iter... | Convert row ID's for cached table rows in transactions | [
"Convert",
"row",
"ID",
"s",
"for",
"cached",
"table",
"rows",
"in",
"transactions"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/TransactionManager.java#L1201-L1224 | train |
VoltDB/voltdb | src/frontend/org/voltdb/messaging/VoltDbMessageFactory.java | VoltDbMessageFactory.instantiate_local | @Override
protected VoltMessage instantiate_local(byte messageType)
{
// instantiate a new message instance according to the id
VoltMessage message = null;
switch (messageType) {
case INITIATE_TASK_ID:
message = new InitiateTaskMessage();
break;
case INITIATE_RESPONSE_ID:
message = new InitiateResponseMessage();
break;
case FRAGMENT_TASK_ID:
message = new FragmentTaskMessage();
break;
case FRAGMENT_RESPONSE_ID:
message = new FragmentResponseMessage();
break;
case PARTICIPANT_NOTICE_ID:
message = new MultiPartitionParticipantMessage();
break;
case COALESCED_HEARTBEAT_ID:
message = new CoalescedHeartbeatMessage();
break;
case COMPLETE_TRANSACTION_ID:
message = new CompleteTransactionMessage();
break;
case COMPLETE_TRANSACTION_RESPONSE_ID:
message = new CompleteTransactionResponseMessage();
break;
case IV2_INITIATE_TASK_ID:
message = new Iv2InitiateTaskMessage();
break;
case IV2_REPAIR_LOG_REQUEST:
message = new Iv2RepairLogRequestMessage();
break;
case IV2_REPAIR_LOG_RESPONSE:
message = new Iv2RepairLogResponseMessage();
break;
case REJOIN_RESPONSE_ID:
message = new RejoinMessage();
break;
case REJOIN_DATA_ID:
message = new RejoinDataMessage();
break;
case REJOIN_DATA_ACK_ID:
message = new RejoinDataAckMessage();
break;
case FRAGMENT_TASK_LOG_ID:
message = new FragmentTaskLogMessage();
break;
case IV2_LOG_FAULT_ID:
message = new Iv2LogFaultMessage();
break;
case IV2_EOL_ID:
message = new Iv2EndOfLogMessage();
break;
case DUMP:
message = new DumpMessage();
break;
case MP_REPLAY_ID:
message = new MpReplayMessage();
break;
case MP_REPLAY_ACK_ID:
message = new MpReplayAckMessage();
break;
case SNAPSHOT_CHECK_REQUEST_ID:
message = new SnapshotCheckRequestMessage();
break;
case SNAPSHOT_CHECK_RESPONSE_ID:
message = new SnapshotCheckResponseMessage();
break;
case IV2_REPAIR_LOG_TRUNCATION:
message = new RepairLogTruncationMessage();
break;
case DR2_MULTIPART_TASK_ID:
message = new Dr2MultipartTaskMessage();
break;
case DR2_MULTIPART_RESPONSE_ID:
message = new Dr2MultipartResponseMessage();
break;
case DUMMY_TRANSACTION_TASK_ID:
message = new DummyTransactionTaskMessage();
break;
case DUMMY_TRANSACTION_RESPONSE_ID:
message = new DummyTransactionResponseMessage();
break;
case Migrate_Partition_Leader_MESSAGE_ID:
message = new MigratePartitionLeaderMessage();
break;
case DUMP_PLAN_ID:
message = new DumpPlanThenExitMessage();
break;
case FLUSH_RO_TXN_MESSAGE_ID:
message = new MPBacklogFlushMessage();
break;
default:
message = null;
}
return message;
} | java | @Override
protected VoltMessage instantiate_local(byte messageType)
{
// instantiate a new message instance according to the id
VoltMessage message = null;
switch (messageType) {
case INITIATE_TASK_ID:
message = new InitiateTaskMessage();
break;
case INITIATE_RESPONSE_ID:
message = new InitiateResponseMessage();
break;
case FRAGMENT_TASK_ID:
message = new FragmentTaskMessage();
break;
case FRAGMENT_RESPONSE_ID:
message = new FragmentResponseMessage();
break;
case PARTICIPANT_NOTICE_ID:
message = new MultiPartitionParticipantMessage();
break;
case COALESCED_HEARTBEAT_ID:
message = new CoalescedHeartbeatMessage();
break;
case COMPLETE_TRANSACTION_ID:
message = new CompleteTransactionMessage();
break;
case COMPLETE_TRANSACTION_RESPONSE_ID:
message = new CompleteTransactionResponseMessage();
break;
case IV2_INITIATE_TASK_ID:
message = new Iv2InitiateTaskMessage();
break;
case IV2_REPAIR_LOG_REQUEST:
message = new Iv2RepairLogRequestMessage();
break;
case IV2_REPAIR_LOG_RESPONSE:
message = new Iv2RepairLogResponseMessage();
break;
case REJOIN_RESPONSE_ID:
message = new RejoinMessage();
break;
case REJOIN_DATA_ID:
message = new RejoinDataMessage();
break;
case REJOIN_DATA_ACK_ID:
message = new RejoinDataAckMessage();
break;
case FRAGMENT_TASK_LOG_ID:
message = new FragmentTaskLogMessage();
break;
case IV2_LOG_FAULT_ID:
message = new Iv2LogFaultMessage();
break;
case IV2_EOL_ID:
message = new Iv2EndOfLogMessage();
break;
case DUMP:
message = new DumpMessage();
break;
case MP_REPLAY_ID:
message = new MpReplayMessage();
break;
case MP_REPLAY_ACK_ID:
message = new MpReplayAckMessage();
break;
case SNAPSHOT_CHECK_REQUEST_ID:
message = new SnapshotCheckRequestMessage();
break;
case SNAPSHOT_CHECK_RESPONSE_ID:
message = new SnapshotCheckResponseMessage();
break;
case IV2_REPAIR_LOG_TRUNCATION:
message = new RepairLogTruncationMessage();
break;
case DR2_MULTIPART_TASK_ID:
message = new Dr2MultipartTaskMessage();
break;
case DR2_MULTIPART_RESPONSE_ID:
message = new Dr2MultipartResponseMessage();
break;
case DUMMY_TRANSACTION_TASK_ID:
message = new DummyTransactionTaskMessage();
break;
case DUMMY_TRANSACTION_RESPONSE_ID:
message = new DummyTransactionResponseMessage();
break;
case Migrate_Partition_Leader_MESSAGE_ID:
message = new MigratePartitionLeaderMessage();
break;
case DUMP_PLAN_ID:
message = new DumpPlanThenExitMessage();
break;
case FLUSH_RO_TXN_MESSAGE_ID:
message = new MPBacklogFlushMessage();
break;
default:
message = null;
}
return message;
} | [
"@",
"Override",
"protected",
"VoltMessage",
"instantiate_local",
"(",
"byte",
"messageType",
")",
"{",
"// instantiate a new message instance according to the id",
"VoltMessage",
"message",
"=",
"null",
";",
"switch",
"(",
"messageType",
")",
"{",
"case",
"INITIATE_TASK_... | Overridden by subclasses to create message types unknown by voltcore
@param messageType
@return | [
"Overridden",
"by",
"subclasses",
"to",
"create",
"message",
"types",
"unknown",
"by",
"voltcore"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/messaging/VoltDbMessageFactory.java#L63-L164 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/Database.java | Database.clearStructures | void clearStructures() {
if (schemaManager != null) {
schemaManager.clearStructures();
}
granteeManager = null;
userManager = null;
nameManager = null;
schemaManager = null;
sessionManager = null;
dbInfo = null;
} | java | void clearStructures() {
if (schemaManager != null) {
schemaManager.clearStructures();
}
granteeManager = null;
userManager = null;
nameManager = null;
schemaManager = null;
sessionManager = null;
dbInfo = null;
} | [
"void",
"clearStructures",
"(",
")",
"{",
"if",
"(",
"schemaManager",
"!=",
"null",
")",
"{",
"schemaManager",
".",
"clearStructures",
"(",
")",
";",
"}",
"granteeManager",
"=",
"null",
";",
"userManager",
"=",
"null",
";",
"nameManager",
"=",
"null",
";",... | Clears the data structuress, making them elligible for garbage collection. | [
"Clears",
"the",
"data",
"structuress",
"making",
"them",
"elligible",
"for",
"garbage",
"collection",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/Database.java#L394-L406 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/Database.java | Database.getScript | public Result getScript(boolean indexRoots) {
Result r = Result.newSingleColumnResult("COMMAND", Type.SQL_VARCHAR);
String[] list = getSettingsSQL();
addRows(r, list);
list = getGranteeManager().getSQL();
addRows(r, list);
// schemas and schema objects such as tables, sequences, etc.
list = schemaManager.getSQLArray();
addRows(r, list);
// index roots
if (indexRoots) {
list = schemaManager.getIndexRootsSQL();
addRows(r, list);
}
// user session start schema names
list = getUserManager().getInitialSchemaSQL();
addRows(r, list);
// grantee rights
list = getGranteeManager().getRightstSQL();
addRows(r, list);
list = getPropertiesSQL();
addRows(r, list);
return r;
} | java | public Result getScript(boolean indexRoots) {
Result r = Result.newSingleColumnResult("COMMAND", Type.SQL_VARCHAR);
String[] list = getSettingsSQL();
addRows(r, list);
list = getGranteeManager().getSQL();
addRows(r, list);
// schemas and schema objects such as tables, sequences, etc.
list = schemaManager.getSQLArray();
addRows(r, list);
// index roots
if (indexRoots) {
list = schemaManager.getIndexRootsSQL();
addRows(r, list);
}
// user session start schema names
list = getUserManager().getInitialSchemaSQL();
addRows(r, list);
// grantee rights
list = getGranteeManager().getRightstSQL();
addRows(r, list);
list = getPropertiesSQL();
addRows(r, list);
return r;
} | [
"public",
"Result",
"getScript",
"(",
"boolean",
"indexRoots",
")",
"{",
"Result",
"r",
"=",
"Result",
".",
"newSingleColumnResult",
"(",
"\"COMMAND\"",
",",
"Type",
".",
"SQL_VARCHAR",
")",
";",
"String",
"[",
"]",
"list",
"=",
"getSettingsSQL",
"(",
")",
... | Returns the schema and authorisation statements for the database. | [
"Returns",
"the",
"schema",
"and",
"authorisation",
"statements",
"for",
"the",
"database",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/Database.java#L767-L805 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/ParserDQL.java | ParserDQL.readWindowSpecification | private Expression readWindowSpecification(int tokenT, Expression aggExpr) {
SortAndSlice sortAndSlice = null;
readThis(Tokens.OPENBRACKET);
List<Expression> partitionByList = new ArrayList<>();
if (token.tokenType == Tokens.PARTITION) {
read();
readThis(Tokens.BY);
while (true) {
Expression partitionExpr = XreadValueExpression();
partitionByList.add(partitionExpr);
if (token.tokenType == Tokens.COMMA) {
read();
continue;
}
break;
}
}
if (token.tokenType == Tokens.ORDER) {
// order by clause
read();
readThis(Tokens.BY);
sortAndSlice = XreadOrderBy();
}
readThis(Tokens.CLOSEBRACKET);
// We don't really care about aggExpr any more. It has the
// aggregate expression as a non-windowed expression. We do
// care about its parameters and whether it's specified as
// unique though.
assert(aggExpr == null || aggExpr instanceof ExpressionAggregate);
Expression nodes[];
boolean isDistinct;
if (aggExpr != null) {
ExpressionAggregate winAggExpr = (ExpressionAggregate)aggExpr;
nodes = winAggExpr.nodes;
isDistinct = winAggExpr.isDistinctAggregate;
} else {
nodes = Expression.emptyExpressionArray;
isDistinct = false;
}
ExpressionWindowed windowedExpr = new ExpressionWindowed(tokenT,
nodes,
isDistinct,
sortAndSlice,
partitionByList);
return windowedExpr;
} | java | private Expression readWindowSpecification(int tokenT, Expression aggExpr) {
SortAndSlice sortAndSlice = null;
readThis(Tokens.OPENBRACKET);
List<Expression> partitionByList = new ArrayList<>();
if (token.tokenType == Tokens.PARTITION) {
read();
readThis(Tokens.BY);
while (true) {
Expression partitionExpr = XreadValueExpression();
partitionByList.add(partitionExpr);
if (token.tokenType == Tokens.COMMA) {
read();
continue;
}
break;
}
}
if (token.tokenType == Tokens.ORDER) {
// order by clause
read();
readThis(Tokens.BY);
sortAndSlice = XreadOrderBy();
}
readThis(Tokens.CLOSEBRACKET);
// We don't really care about aggExpr any more. It has the
// aggregate expression as a non-windowed expression. We do
// care about its parameters and whether it's specified as
// unique though.
assert(aggExpr == null || aggExpr instanceof ExpressionAggregate);
Expression nodes[];
boolean isDistinct;
if (aggExpr != null) {
ExpressionAggregate winAggExpr = (ExpressionAggregate)aggExpr;
nodes = winAggExpr.nodes;
isDistinct = winAggExpr.isDistinctAggregate;
} else {
nodes = Expression.emptyExpressionArray;
isDistinct = false;
}
ExpressionWindowed windowedExpr = new ExpressionWindowed(tokenT,
nodes,
isDistinct,
sortAndSlice,
partitionByList);
return windowedExpr;
} | [
"private",
"Expression",
"readWindowSpecification",
"(",
"int",
"tokenT",
",",
"Expression",
"aggExpr",
")",
"{",
"SortAndSlice",
"sortAndSlice",
"=",
"null",
";",
"readThis",
"(",
"Tokens",
".",
"OPENBRACKET",
")",
";",
"List",
"<",
"Expression",
">",
"partitio... | This is a minimal parsing of the Window Specification. We only use
partition by and order by lists. There is a lot of complexity in the
full SQL specification which we don't parse at all.
@param tokenT
@param aggExpr
@return | [
"This",
"is",
"a",
"minimal",
"parsing",
"of",
"the",
"Window",
"Specification",
".",
"We",
"only",
"use",
"partition",
"by",
"and",
"order",
"by",
"lists",
".",
"There",
"is",
"a",
"lot",
"of",
"complexity",
"in",
"the",
"full",
"SQL",
"specification",
... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/ParserDQL.java#L1734-L1786 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/ParserDQL.java | ParserDQL.XStartsWithPredicateRightPart | private ExpressionLogical XStartsWithPredicateRightPart(Expression left) {
readThis(Tokens.WITH);
if (token.tokenType == Tokens.QUESTION) { // handle user parameter case
Expression right = XreadRowValuePredicand();
if (left.isParam() && right.isParam()) { // again make sure the left side is valid
throw Error.error(ErrorCode.X_42567);
}
/** In this case, we make the right parameter as the lower bound,
* and the right parameter concatenating a special char (greater than any other chars) as the upper bound.
* It now becomes a range scan for all the strings with right parameter as its prefix.
*/
Expression l = new ExpressionLogical(OpTypes.GREATER_EQUAL, left, right);
Expression r = new ExpressionLogical(OpTypes.SMALLER_EQUAL, left,
new ExpressionArithmetic(OpTypes.CONCAT, right, new ExpressionValue("\uffff", Type.SQL_CHAR)));
return new ExpressionLogical(OpTypes.AND, l, r);
} else { // handle plain string value and the column
Expression right = XreadStringValueExpression();
return new ExpressionStartsWith(left, right, this.isCheckOrTriggerCondition);
}
} | java | private ExpressionLogical XStartsWithPredicateRightPart(Expression left) {
readThis(Tokens.WITH);
if (token.tokenType == Tokens.QUESTION) { // handle user parameter case
Expression right = XreadRowValuePredicand();
if (left.isParam() && right.isParam()) { // again make sure the left side is valid
throw Error.error(ErrorCode.X_42567);
}
/** In this case, we make the right parameter as the lower bound,
* and the right parameter concatenating a special char (greater than any other chars) as the upper bound.
* It now becomes a range scan for all the strings with right parameter as its prefix.
*/
Expression l = new ExpressionLogical(OpTypes.GREATER_EQUAL, left, right);
Expression r = new ExpressionLogical(OpTypes.SMALLER_EQUAL, left,
new ExpressionArithmetic(OpTypes.CONCAT, right, new ExpressionValue("\uffff", Type.SQL_CHAR)));
return new ExpressionLogical(OpTypes.AND, l, r);
} else { // handle plain string value and the column
Expression right = XreadStringValueExpression();
return new ExpressionStartsWith(left, right, this.isCheckOrTriggerCondition);
}
} | [
"private",
"ExpressionLogical",
"XStartsWithPredicateRightPart",
"(",
"Expression",
"left",
")",
"{",
"readThis",
"(",
"Tokens",
".",
"WITH",
")",
";",
"if",
"(",
"token",
".",
"tokenType",
"==",
"Tokens",
".",
"QUESTION",
")",
"{",
"// handle user parameter case"... | Scan the right-side string value, return a STARTS WITH Expression for generating XML
@param a ExpressionColumn | [
"Scan",
"the",
"right",
"-",
"side",
"string",
"value",
"return",
"a",
"STARTS",
"WITH",
"Expression",
"for",
"generating",
"XML"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/ParserDQL.java#L3384-L3405 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/ParserDQL.java | ParserDQL.XreadRowValueConstructor | Expression XreadRowValueConstructor() {
Expression e;
e = XreadExplicitRowValueConstructorOrNull();
if (e != null) {
return e;
}
e = XreadRowOrCommonValueExpression();
if (e != null) {
return e;
}
return XreadBooleanValueExpression();
} | java | Expression XreadRowValueConstructor() {
Expression e;
e = XreadExplicitRowValueConstructorOrNull();
if (e != null) {
return e;
}
e = XreadRowOrCommonValueExpression();
if (e != null) {
return e;
}
return XreadBooleanValueExpression();
} | [
"Expression",
"XreadRowValueConstructor",
"(",
")",
"{",
"Expression",
"e",
";",
"e",
"=",
"XreadExplicitRowValueConstructorOrNull",
"(",
")",
";",
"if",
"(",
"e",
"!=",
"null",
")",
"{",
"return",
"e",
";",
"}",
"e",
"=",
"XreadRowOrCommonValueExpression",
"(... | ISSUE - XreadCommonValueExpression and XreadBooleanValueExpression should merge | [
"ISSUE",
"-",
"XreadCommonValueExpression",
"and",
"XreadBooleanValueExpression",
"should",
"merge"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/ParserDQL.java#L3505-L3522 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/ParserDQL.java | ParserDQL.XreadExplicitRowValueConstructorOrNull | Expression XreadExplicitRowValueConstructorOrNull() {
Expression e;
switch (token.tokenType) {
case Tokens.OPENBRACKET : {
read();
int position = getPosition();
int brackets = readOpenBrackets();
switch (token.tokenType) {
case Tokens.TABLE :
case Tokens.VALUES :
case Tokens.SELECT :
rewind(position);
SubQuery sq = XreadSubqueryBody(false,
OpTypes.ROW_SUBQUERY);
readThis(Tokens.CLOSEBRACKET);
return new Expression(OpTypes.ROW_SUBQUERY, sq);
default :
rewind(position);
e = XreadRowElementList(true);
readThis(Tokens.CLOSEBRACKET);
return e;
}
}
case Tokens.ROW : {
read();
readThis(Tokens.OPENBRACKET);
e = XreadRowElementList(false);
readThis(Tokens.CLOSEBRACKET);
return e;
}
}
return null;
} | java | Expression XreadExplicitRowValueConstructorOrNull() {
Expression e;
switch (token.tokenType) {
case Tokens.OPENBRACKET : {
read();
int position = getPosition();
int brackets = readOpenBrackets();
switch (token.tokenType) {
case Tokens.TABLE :
case Tokens.VALUES :
case Tokens.SELECT :
rewind(position);
SubQuery sq = XreadSubqueryBody(false,
OpTypes.ROW_SUBQUERY);
readThis(Tokens.CLOSEBRACKET);
return new Expression(OpTypes.ROW_SUBQUERY, sq);
default :
rewind(position);
e = XreadRowElementList(true);
readThis(Tokens.CLOSEBRACKET);
return e;
}
}
case Tokens.ROW : {
read();
readThis(Tokens.OPENBRACKET);
e = XreadRowElementList(false);
readThis(Tokens.CLOSEBRACKET);
return e;
}
}
return null;
} | [
"Expression",
"XreadExplicitRowValueConstructorOrNull",
"(",
")",
"{",
"Expression",
"e",
";",
"switch",
"(",
"token",
".",
"tokenType",
")",
"{",
"case",
"Tokens",
".",
"OPENBRACKET",
":",
"{",
"read",
"(",
")",
";",
"int",
"position",
"=",
"getPosition",
"... | must be called in conjusnction with <parenthesized .. | [
"must",
"be",
"called",
"in",
"conjusnction",
"with",
"<parenthesized",
".."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/ParserDQL.java#L3526-L3575 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/ParserDQL.java | ParserDQL.readCaseWhen | private Expression readCaseWhen(final Expression l) {
readThis(Tokens.WHEN);
Expression condition = null;
if (l == null) {
condition = XreadBooleanValueExpression();
} else {
while (true) {
Expression newCondition = XreadPredicateRightPart(l);
if (l == newCondition) {
newCondition =
new ExpressionLogical(l, XreadRowValuePredicand());
}
if (condition == null) {
condition = newCondition;
} else {
condition = new ExpressionLogical(OpTypes.OR, condition,
newCondition);
}
if (token.tokenType == Tokens.COMMA) {
read();
} else {
break;
}
}
}
readThis(Tokens.THEN);
Expression current = XreadValueExpression();
Expression elseExpr = null;
if (token.tokenType == Tokens.WHEN) {
elseExpr = readCaseWhen(l);
} else if (token.tokenType == Tokens.ELSE) {
read();
elseExpr = XreadValueExpression();
readThis(Tokens.END);
readIfThis(Tokens.CASE);
} else {
elseExpr = new ExpressionValue((Object) null, Type.SQL_ALL_TYPES);
readThis(Tokens.END);
readIfThis(Tokens.CASE);
}
Expression alternatives = new ExpressionOp(OpTypes.ALTERNATIVE,
current, elseExpr);
Expression casewhen = new ExpressionOp(OpTypes.CASEWHEN, condition,
alternatives);
return casewhen;
} | java | private Expression readCaseWhen(final Expression l) {
readThis(Tokens.WHEN);
Expression condition = null;
if (l == null) {
condition = XreadBooleanValueExpression();
} else {
while (true) {
Expression newCondition = XreadPredicateRightPart(l);
if (l == newCondition) {
newCondition =
new ExpressionLogical(l, XreadRowValuePredicand());
}
if (condition == null) {
condition = newCondition;
} else {
condition = new ExpressionLogical(OpTypes.OR, condition,
newCondition);
}
if (token.tokenType == Tokens.COMMA) {
read();
} else {
break;
}
}
}
readThis(Tokens.THEN);
Expression current = XreadValueExpression();
Expression elseExpr = null;
if (token.tokenType == Tokens.WHEN) {
elseExpr = readCaseWhen(l);
} else if (token.tokenType == Tokens.ELSE) {
read();
elseExpr = XreadValueExpression();
readThis(Tokens.END);
readIfThis(Tokens.CASE);
} else {
elseExpr = new ExpressionValue((Object) null, Type.SQL_ALL_TYPES);
readThis(Tokens.END);
readIfThis(Tokens.CASE);
}
Expression alternatives = new ExpressionOp(OpTypes.ALTERNATIVE,
current, elseExpr);
Expression casewhen = new ExpressionOp(OpTypes.CASEWHEN, condition,
alternatives);
return casewhen;
} | [
"private",
"Expression",
"readCaseWhen",
"(",
"final",
"Expression",
"l",
")",
"{",
"readThis",
"(",
"Tokens",
".",
"WHEN",
")",
";",
"Expression",
"condition",
"=",
"null",
";",
"if",
"(",
"l",
"==",
"null",
")",
"{",
"condition",
"=",
"XreadBooleanValueE... | Reads part of a CASE .. WHEN expression | [
"Reads",
"part",
"of",
"a",
"CASE",
"..",
"WHEN",
"expression"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/ParserDQL.java#L4011-L4070 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/ParserDQL.java | ParserDQL.readCaseWhenExpression | private Expression readCaseWhenExpression() {
Expression l = null;
read();
readThis(Tokens.OPENBRACKET);
l = XreadBooleanValueExpression();
readThis(Tokens.COMMA);
Expression thenelse = XreadRowValueExpression();
readThis(Tokens.COMMA);
thenelse = new ExpressionOp(OpTypes.ALTERNATIVE, thenelse,
XreadValueExpression());
l = new ExpressionOp(OpTypes.CASEWHEN, l, thenelse);
readThis(Tokens.CLOSEBRACKET);
return l;
} | java | private Expression readCaseWhenExpression() {
Expression l = null;
read();
readThis(Tokens.OPENBRACKET);
l = XreadBooleanValueExpression();
readThis(Tokens.COMMA);
Expression thenelse = XreadRowValueExpression();
readThis(Tokens.COMMA);
thenelse = new ExpressionOp(OpTypes.ALTERNATIVE, thenelse,
XreadValueExpression());
l = new ExpressionOp(OpTypes.CASEWHEN, l, thenelse);
readThis(Tokens.CLOSEBRACKET);
return l;
} | [
"private",
"Expression",
"readCaseWhenExpression",
"(",
")",
"{",
"Expression",
"l",
"=",
"null",
";",
"read",
"(",
")",
";",
"readThis",
"(",
"Tokens",
".",
"OPENBRACKET",
")",
";",
"l",
"=",
"XreadBooleanValueExpression",
"(",
")",
";",
"readThis",
"(",
... | reads a CASEWHEN expression | [
"reads",
"a",
"CASEWHEN",
"expression"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/ParserDQL.java#L4075-L4097 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/ParserDQL.java | ParserDQL.readCastExpression | private Expression readCastExpression() {
boolean isConvert = token.tokenType == Tokens.CONVERT;
read();
readThis(Tokens.OPENBRACKET);
Expression l = this.XreadValueExpressionOrNull();
if (isConvert) {
readThis(Tokens.COMMA);
} else {
readThis(Tokens.AS);
}
Type typeObject = readTypeDefinition(true);
if (l.isParam()) {
l.setDataType(session, typeObject);
}
l = new ExpressionOp(l, typeObject);
readThis(Tokens.CLOSEBRACKET);
return l;
} | java | private Expression readCastExpression() {
boolean isConvert = token.tokenType == Tokens.CONVERT;
read();
readThis(Tokens.OPENBRACKET);
Expression l = this.XreadValueExpressionOrNull();
if (isConvert) {
readThis(Tokens.COMMA);
} else {
readThis(Tokens.AS);
}
Type typeObject = readTypeDefinition(true);
if (l.isParam()) {
l.setDataType(session, typeObject);
}
l = new ExpressionOp(l, typeObject);
readThis(Tokens.CLOSEBRACKET);
return l;
} | [
"private",
"Expression",
"readCastExpression",
"(",
")",
"{",
"boolean",
"isConvert",
"=",
"token",
".",
"tokenType",
"==",
"Tokens",
".",
"CONVERT",
";",
"read",
"(",
")",
";",
"readThis",
"(",
"Tokens",
".",
"OPENBRACKET",
")",
";",
"Expression",
"l",
"=... | Reads a CAST or CONVERT expression | [
"Reads",
"a",
"CAST",
"or",
"CONVERT",
"expression"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/ParserDQL.java#L4102-L4128 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/ParserDQL.java | ParserDQL.readNullIfExpression | private Expression readNullIfExpression() {
// turn into a CASEWHEN
read();
readThis(Tokens.OPENBRACKET);
Expression c = XreadValueExpression();
readThis(Tokens.COMMA);
Expression thenelse =
new ExpressionOp(OpTypes.ALTERNATIVE,
new ExpressionValue((Object) null, (Type) null),
c);
c = new ExpressionLogical(c, XreadValueExpression());
c = new ExpressionOp(OpTypes.CASEWHEN, c, thenelse);
readThis(Tokens.CLOSEBRACKET);
return c;
} | java | private Expression readNullIfExpression() {
// turn into a CASEWHEN
read();
readThis(Tokens.OPENBRACKET);
Expression c = XreadValueExpression();
readThis(Tokens.COMMA);
Expression thenelse =
new ExpressionOp(OpTypes.ALTERNATIVE,
new ExpressionValue((Object) null, (Type) null),
c);
c = new ExpressionLogical(c, XreadValueExpression());
c = new ExpressionOp(OpTypes.CASEWHEN, c, thenelse);
readThis(Tokens.CLOSEBRACKET);
return c;
} | [
"private",
"Expression",
"readNullIfExpression",
"(",
")",
"{",
"// turn into a CASEWHEN",
"read",
"(",
")",
";",
"readThis",
"(",
"Tokens",
".",
"OPENBRACKET",
")",
";",
"Expression",
"c",
"=",
"XreadValueExpression",
"(",
")",
";",
"readThis",
"(",
"Tokens",
... | Reads a NULLIF expression | [
"Reads",
"a",
"NULLIF",
"expression"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/ParserDQL.java#L4278-L4299 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/ParserDQL.java | ParserDQL.readCoalesceExpression | private Expression readCoalesceExpression() {
Expression c = null;
// turn into a CASEWHEN
read();
readThis(Tokens.OPENBRACKET);
Expression leaf = null;
while (true) {
Expression current = XreadValueExpression();
if (leaf != null && token.tokenType == Tokens.CLOSEBRACKET) {
readThis(Tokens.CLOSEBRACKET);
leaf.setLeftNode(current);
break;
}
Expression condition = new ExpressionLogical(OpTypes.IS_NULL,
current);
Expression alternatives = new ExpressionOp(OpTypes.ALTERNATIVE,
new ExpressionValue((Object) null, (Type) null), current);
Expression casewhen = new ExpressionOp(OpTypes.CASEWHEN,
condition, alternatives);
if (c == null) {
c = casewhen;
} else {
leaf.setLeftNode(casewhen);
}
leaf = alternatives;
readThis(Tokens.COMMA);
}
return c;
} | java | private Expression readCoalesceExpression() {
Expression c = null;
// turn into a CASEWHEN
read();
readThis(Tokens.OPENBRACKET);
Expression leaf = null;
while (true) {
Expression current = XreadValueExpression();
if (leaf != null && token.tokenType == Tokens.CLOSEBRACKET) {
readThis(Tokens.CLOSEBRACKET);
leaf.setLeftNode(current);
break;
}
Expression condition = new ExpressionLogical(OpTypes.IS_NULL,
current);
Expression alternatives = new ExpressionOp(OpTypes.ALTERNATIVE,
new ExpressionValue((Object) null, (Type) null), current);
Expression casewhen = new ExpressionOp(OpTypes.CASEWHEN,
condition, alternatives);
if (c == null) {
c = casewhen;
} else {
leaf.setLeftNode(casewhen);
}
leaf = alternatives;
readThis(Tokens.COMMA);
}
return c;
} | [
"private",
"Expression",
"readCoalesceExpression",
"(",
")",
"{",
"Expression",
"c",
"=",
"null",
";",
"// turn into a CASEWHEN",
"read",
"(",
")",
";",
"readThis",
"(",
"Tokens",
".",
"OPENBRACKET",
")",
";",
"Expression",
"leaf",
"=",
"null",
";",
"while",
... | Reads a COALESE or IFNULL expression | [
"Reads",
"a",
"COALESE",
"or",
"IFNULL",
"expression"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/ParserDQL.java#L4304-L4343 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/ParserDQL.java | ParserDQL.compileCursorSpecification | StatementDMQL compileCursorSpecification() {
QueryExpression queryExpression = XreadQueryExpression();
queryExpression.setAsTopLevel();
queryExpression.resolve(session);
if (token.tokenType == Tokens.FOR) {
read();
if (token.tokenType == Tokens.READ) {
read();
readThis(Tokens.ONLY);
} else {
readThis(Tokens.UPDATE);
if (token.tokenType == Tokens.OF) {
readThis(Tokens.OF);
OrderedHashSet colNames = readColumnNameList(null, false);
}
}
}
StatementDMQL cs = new StatementQuery(session, queryExpression,
compileContext);
return cs;
} | java | StatementDMQL compileCursorSpecification() {
QueryExpression queryExpression = XreadQueryExpression();
queryExpression.setAsTopLevel();
queryExpression.resolve(session);
if (token.tokenType == Tokens.FOR) {
read();
if (token.tokenType == Tokens.READ) {
read();
readThis(Tokens.ONLY);
} else {
readThis(Tokens.UPDATE);
if (token.tokenType == Tokens.OF) {
readThis(Tokens.OF);
OrderedHashSet colNames = readColumnNameList(null, false);
}
}
}
StatementDMQL cs = new StatementQuery(session, queryExpression,
compileContext);
return cs;
} | [
"StatementDMQL",
"compileCursorSpecification",
"(",
")",
"{",
"QueryExpression",
"queryExpression",
"=",
"XreadQueryExpression",
"(",
")",
";",
"queryExpression",
".",
"setAsTopLevel",
"(",
")",
";",
"queryExpression",
".",
"resolve",
"(",
"session",
")",
";",
"if",... | Retrieves a SELECT or other query expression Statement from this parse context. | [
"Retrieves",
"a",
"SELECT",
"or",
"other",
"query",
"expression",
"Statement",
"from",
"this",
"parse",
"context",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/ParserDQL.java#L4965-L4992 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/types/BinaryData.java | BinaryData.toLong | public long toLong() {
byte[] data = getBytes();
if (data == null || data.length <= 0 || data.length > 8) {
// Assume that we're in a numeric context and that the user
// made a typo entering a hex string.
throw Error.error(ErrorCode.X_42585); // malformed numeric constant
}
byte[] dataWithLeadingZeros = new byte[] {0, 0, 0, 0, 0, 0, 0, 0};
int lenDiff = 8 - data.length;
for (int j = lenDiff; j < 8; ++j) {
dataWithLeadingZeros[j] = data[j - lenDiff];
}
BigInteger bi = new BigInteger(dataWithLeadingZeros);
return bi.longValue();
} | java | public long toLong() {
byte[] data = getBytes();
if (data == null || data.length <= 0 || data.length > 8) {
// Assume that we're in a numeric context and that the user
// made a typo entering a hex string.
throw Error.error(ErrorCode.X_42585); // malformed numeric constant
}
byte[] dataWithLeadingZeros = new byte[] {0, 0, 0, 0, 0, 0, 0, 0};
int lenDiff = 8 - data.length;
for (int j = lenDiff; j < 8; ++j) {
dataWithLeadingZeros[j] = data[j - lenDiff];
}
BigInteger bi = new BigInteger(dataWithLeadingZeros);
return bi.longValue();
} | [
"public",
"long",
"toLong",
"(",
")",
"{",
"byte",
"[",
"]",
"data",
"=",
"getBytes",
"(",
")",
";",
"if",
"(",
"data",
"==",
"null",
"||",
"data",
".",
"length",
"<=",
"0",
"||",
"data",
".",
"length",
">",
"8",
")",
"{",
"// Assume that we're in ... | Given a sequence of bytes that would otherwise be a
VARBINARY constant, return a long value, with the
understanding that the caller has determined that this
value is in a numeric context.
Returns true for a successful conversion and false otherwise.
We assume that the bytes are representing a
64-bit two's complement integer:
- a constant with no digits throws a "malformed numeric constant" exception
- a constant with more than 16 digits throws a "malformed numeric constant" exception
- a constant that is shorter than 16 digits is implicitly zero-extended
(i.e., constants with less than 16 digits are always positive)
These are the VoltDB classes that handle hex literal constants:
voltdb.ParameterConverter
voltdb.expressions.ConstantValueExpression
Each of these code paths need to handle hex literals in the same way.
Note that sqlcmd must parse parameters to execute stored procedures and calls common code
in SQLParser for handling hex literals.
(VMC support for hex literals is still TBD at this time.)
@return a long value | [
"Given",
"a",
"sequence",
"of",
"bytes",
"that",
"would",
"otherwise",
"be",
"a",
"VARBINARY",
"constant",
"return",
"a",
"long",
"value",
"with",
"the",
"understanding",
"that",
"the",
"caller",
"has",
"determined",
"that",
"this",
"value",
"is",
"in",
"a",... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/types/BinaryData.java#L298-L314 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/HSQLFileParser.java | HSQLFileParser.main | public static void main(String args[]) {
Statement stmts[] = null;
try {
stmts = getStatements(args[0]);
} catch (Throwable e) {
System.out.println(e.getMessage());
return;
}
for (Statement s : stmts) {
System.out.print(s.statement);
}
} | java | public static void main(String args[]) {
Statement stmts[] = null;
try {
stmts = getStatements(args[0]);
} catch (Throwable e) {
System.out.println(e.getMessage());
return;
}
for (Statement s : stmts) {
System.out.print(s.statement);
}
} | [
"public",
"static",
"void",
"main",
"(",
"String",
"args",
"[",
"]",
")",
"{",
"Statement",
"stmts",
"[",
"]",
"=",
"null",
";",
"try",
"{",
"stmts",
"=",
"getStatements",
"(",
"args",
"[",
"0",
"]",
")",
";",
"}",
"catch",
"(",
"Throwable",
"e",
... | Run the parser as a stand-alone tool sending output to standard out.
@param arg[0] is the file of sql commands to be processed. | [
"Run",
"the",
"parser",
"as",
"a",
"stand",
"-",
"alone",
"tool",
"sending",
"output",
"to",
"standard",
"out",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/HSQLFileParser.java#L122-L133 | train |
VoltDB/voltdb | src/frontend/org/voltdb/iv2/LeaderAppointer.java | LeaderAppointer.watchPartition | void watchPartition(int pid, ExecutorService es, boolean shouldBlock)
throws InterruptedException, ExecutionException
{
String dir = LeaderElector.electionDirForPartition(VoltZK.leaders_initiators, pid);
m_callbacks.put(pid, new PartitionCallback(pid));
BabySitter babySitter;
if (shouldBlock) {
babySitter = BabySitter.blockingFactory(m_zk, dir, m_callbacks.get(pid), es).getFirst();
} else {
babySitter = BabySitter.nonblockingFactory(m_zk, dir, m_callbacks.get(pid), es);
}
m_partitionWatchers.put(pid, babySitter);
} | java | void watchPartition(int pid, ExecutorService es, boolean shouldBlock)
throws InterruptedException, ExecutionException
{
String dir = LeaderElector.electionDirForPartition(VoltZK.leaders_initiators, pid);
m_callbacks.put(pid, new PartitionCallback(pid));
BabySitter babySitter;
if (shouldBlock) {
babySitter = BabySitter.blockingFactory(m_zk, dir, m_callbacks.get(pid), es).getFirst();
} else {
babySitter = BabySitter.nonblockingFactory(m_zk, dir, m_callbacks.get(pid), es);
}
m_partitionWatchers.put(pid, babySitter);
} | [
"void",
"watchPartition",
"(",
"int",
"pid",
",",
"ExecutorService",
"es",
",",
"boolean",
"shouldBlock",
")",
"throws",
"InterruptedException",
",",
"ExecutionException",
"{",
"String",
"dir",
"=",
"LeaderElector",
".",
"electionDirForPartition",
"(",
"VoltZK",
"."... | Watch the partition ZK dir in the leader appointer.
This should be called on the elected leader appointer only. m_callbacks and
m_partitionWatchers are only accessed on initialization, promotion,
or elastic add node.
@param pid The partition ID
@param es The executor service to use to construct the baby sitter
@param shouldBlock Whether or not to wait for the initial read of children
@throws KeeperException
@throws InterruptedException
@throws ExecutionException | [
"Watch",
"the",
"partition",
"ZK",
"dir",
"in",
"the",
"leader",
"appointer",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/iv2/LeaderAppointer.java#L549-L563 | train |
VoltDB/voltdb | src/frontend/org/voltdb/iv2/LeaderAppointer.java | LeaderAppointer.getInitialPartitionCount | private int getInitialPartitionCount() throws IllegalAccessException
{
AppointerState currentState = m_state.get();
if (currentState != AppointerState.INIT && currentState != AppointerState.CLUSTER_START) {
throw new IllegalAccessException("Getting cached partition count after cluster " +
"startup");
}
return m_initialPartitionCount;
} | java | private int getInitialPartitionCount() throws IllegalAccessException
{
AppointerState currentState = m_state.get();
if (currentState != AppointerState.INIT && currentState != AppointerState.CLUSTER_START) {
throw new IllegalAccessException("Getting cached partition count after cluster " +
"startup");
}
return m_initialPartitionCount;
} | [
"private",
"int",
"getInitialPartitionCount",
"(",
")",
"throws",
"IllegalAccessException",
"{",
"AppointerState",
"currentState",
"=",
"m_state",
".",
"get",
"(",
")",
";",
"if",
"(",
"currentState",
"!=",
"AppointerState",
".",
"INIT",
"&&",
"currentState",
"!="... | Gets the initial cluster partition count on startup. This can only be called during
initialization. Calling this after initialization throws, because the partition count may
not reflect the actual partition count in the cluster.
@return | [
"Gets",
"the",
"initial",
"cluster",
"partition",
"count",
"on",
"startup",
".",
"This",
"can",
"only",
"be",
"called",
"during",
"initialization",
".",
"Calling",
"this",
"after",
"initialization",
"throws",
"because",
"the",
"partition",
"count",
"may",
"not",... | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/iv2/LeaderAppointer.java#L704-L712 | train |
VoltDB/voltdb | src/frontend/org/voltdb/iv2/LeaderAppointer.java | LeaderAppointer.updatePartitionLeader | public void updatePartitionLeader(int partitionId, long newMasterHISD, boolean isLeaderMigrated) {
PartitionCallback cb = m_callbacks.get(partitionId);
if (cb != null && cb.m_currentLeader != newMasterHISD) {
cb.m_previousLeader = cb.m_currentLeader;
cb.m_currentLeader = newMasterHISD;
cb.m_isLeaderMigrated = isLeaderMigrated;
}
} | java | public void updatePartitionLeader(int partitionId, long newMasterHISD, boolean isLeaderMigrated) {
PartitionCallback cb = m_callbacks.get(partitionId);
if (cb != null && cb.m_currentLeader != newMasterHISD) {
cb.m_previousLeader = cb.m_currentLeader;
cb.m_currentLeader = newMasterHISD;
cb.m_isLeaderMigrated = isLeaderMigrated;
}
} | [
"public",
"void",
"updatePartitionLeader",
"(",
"int",
"partitionId",
",",
"long",
"newMasterHISD",
",",
"boolean",
"isLeaderMigrated",
")",
"{",
"PartitionCallback",
"cb",
"=",
"m_callbacks",
".",
"get",
"(",
"partitionId",
")",
";",
"if",
"(",
"cb",
"!=",
"n... | update the partition call back with current master and replica
@param partitionId partition id
@param newMasterHISD new master HSID | [
"update",
"the",
"partition",
"call",
"back",
"with",
"current",
"master",
"and",
"replica"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/frontend/org/voltdb/iv2/LeaderAppointer.java#L753-L760 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/Collation.java | Collation.compare | public int compare(String a, String b) {
int i;
if (collator == null) {
i = a.compareTo(b);
} else {
i = collator.compare(a, b);
}
return (i == 0) ? 0
: (i < 0 ? -1
: 1);
} | java | public int compare(String a, String b) {
int i;
if (collator == null) {
i = a.compareTo(b);
} else {
i = collator.compare(a, b);
}
return (i == 0) ? 0
: (i < 0 ? -1
: 1);
} | [
"public",
"int",
"compare",
"(",
"String",
"a",
",",
"String",
"b",
")",
"{",
"int",
"i",
";",
"if",
"(",
"collator",
"==",
"null",
")",
"{",
"i",
"=",
"a",
".",
"compareTo",
"(",
"b",
")",
";",
"}",
"else",
"{",
"i",
"=",
"collator",
".",
"c... | returns -1, 0 or +1 | [
"returns",
"-",
"1",
"0",
"or",
"+",
"1"
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/Collation.java#L227-L240 | train |
VoltDB/voltdb | src/hsqldb19b3/org/hsqldb_voltpatches/persist/DataFileBlockManager.java | DataFileBlockManager.get | int get(int rowSize) {
if (lookup.size() == 0) {
return -1;
}
int index = lookup.findFirstGreaterEqualKeyIndex(rowSize);
if (index == -1) {
return -1;
}
// statistics for successful requests only - to be used later for midSize
requestCount++;
requestSize += rowSize;
int length = lookup.getValue(index);
int difference = length - rowSize;
int key = lookup.getKey(index);
lookup.remove(index);
if (difference >= midSize) {
int pos = key + (rowSize / scale);
lookup.add(pos, difference);
} else {
lostFreeBlockSize += difference;
}
return key;
} | java | int get(int rowSize) {
if (lookup.size() == 0) {
return -1;
}
int index = lookup.findFirstGreaterEqualKeyIndex(rowSize);
if (index == -1) {
return -1;
}
// statistics for successful requests only - to be used later for midSize
requestCount++;
requestSize += rowSize;
int length = lookup.getValue(index);
int difference = length - rowSize;
int key = lookup.getKey(index);
lookup.remove(index);
if (difference >= midSize) {
int pos = key + (rowSize / scale);
lookup.add(pos, difference);
} else {
lostFreeBlockSize += difference;
}
return key;
} | [
"int",
"get",
"(",
"int",
"rowSize",
")",
"{",
"if",
"(",
"lookup",
".",
"size",
"(",
")",
"==",
"0",
")",
"{",
"return",
"-",
"1",
";",
"}",
"int",
"index",
"=",
"lookup",
".",
"findFirstGreaterEqualKeyIndex",
"(",
"rowSize",
")",
";",
"if",
"(",
... | Returns the position of a free block or 0. | [
"Returns",
"the",
"position",
"of",
"a",
"free",
"block",
"or",
"0",
"."
] | 8afc1031e475835344b5497ea9e7203bc95475ac | https://github.com/VoltDB/voltdb/blob/8afc1031e475835344b5497ea9e7203bc95475ac/src/hsqldb19b3/org/hsqldb_voltpatches/persist/DataFileBlockManager.java#L97-L129 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.