code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
private static void fixDistributedApproxCountDistinct(
AggregatePlanNode distNode,
AggregatePlanNode coordNode) {
assert (distNode != null);
assert (coordNode != null);
// Patch up any APPROX_COUNT_DISTINCT on the distributed node.
List<ExpressionType> distAggTypes = distNode.getAggregateTypes();
boolean hasApproxCountDistinct = false;
for (int i = 0; i < distAggTypes.size(); ++i) {
ExpressionType et = distAggTypes.get(i);
if (et == ExpressionType.AGGREGATE_APPROX_COUNT_DISTINCT) {
hasApproxCountDistinct = true;
distNode.updateAggregate(i, ExpressionType.AGGREGATE_VALS_TO_HYPERLOGLOG);
}
}
if (hasApproxCountDistinct) {
// Now, patch up any APPROX_COUNT_DISTINCT on the coordinating node.
List<ExpressionType> coordAggTypes = coordNode.getAggregateTypes();
for (int i = 0; i < coordAggTypes.size(); ++i) {
ExpressionType et = coordAggTypes.get(i);
if (et == ExpressionType.AGGREGATE_APPROX_COUNT_DISTINCT) {
coordNode.updateAggregate(i, ExpressionType.AGGREGATE_HYPERLOGLOGS_TO_CARD);
}
}
}
} | java |
protected AbstractPlanNode checkLimitPushDownViability(
AbstractPlanNode root) {
AbstractPlanNode receiveNode = root;
List<ParsedColInfo> orderBys = m_parsedSelect.orderByColumns();
boolean orderByCoversAllGroupBy = m_parsedSelect.groupByIsAnOrderByPermutation();
while ( ! (receiveNode instanceof ReceivePlanNode)) {
// Limitation: can only push past some nodes (see above comment)
// Delete the aggregate node case to handle ENG-6485,
// or say we don't push down meeting aggregate node
// TODO: We might want to optimize/push down "limit" for some cases
if ( ! (receiveNode instanceof OrderByPlanNode) &&
! (receiveNode instanceof ProjectionPlanNode) &&
! isValidAggregateNodeForLimitPushdown(receiveNode,
orderBys, orderByCoversAllGroupBy) ) {
return null;
}
if (receiveNode instanceof OrderByPlanNode) {
// if grouping by the partition key,
// limit can still push down if ordered by aggregate values.
if (! m_parsedSelect.hasPartitionColumnInGroupby() &&
isOrderByAggregationValue(m_parsedSelect.orderByColumns())) {
return null;
}
}
// Traverse...
if (receiveNode.getChildCount() == 0) {
return null;
}
// nothing that allows pushing past has multiple inputs
assert(receiveNode.getChildCount() == 1);
receiveNode = receiveNode.getChild(0);
}
return receiveNode.getChild(0);
} | java |
private static Set<String> getIndexedColumnSetForTable(Table table) {
HashSet<String> columns = new HashSet<>();
for (Index index : table.getIndexes()) {
for (ColumnRef colRef : index.getColumns()) {
columns.add(colRef.getColumn().getTypeName());
}
}
return columns;
} | java |
private static boolean isNullRejecting(Collection<String> tableAliases,
List<AbstractExpression> exprs) {
for (AbstractExpression expr : exprs) {
for (String tableAlias : tableAliases) {
if (ExpressionUtil.isNullRejectingExpression(expr, tableAlias)) {
// We are done at this level
return true;
}
}
}
return false;
} | java |
private int determineIndexOrdering(StmtTableScan tableScan,
int keyComponentCount,
List<AbstractExpression> indexedExprs,
List<ColumnRef> indexedColRefs,
AccessPath retval,
int[] orderSpoilers,
List<AbstractExpression> bindingsForOrder)
{
// Organize a little bit.
ParsedSelectStmt pss = (m_parsedStmt instanceof ParsedSelectStmt)
? ((ParsedSelectStmt)m_parsedStmt)
: null;
boolean hasOrderBy = ( m_parsedStmt.hasOrderByColumns()
&& ( ! m_parsedStmt.orderByColumns().isEmpty() ) );
boolean hasWindowFunctions = (pss != null && pss.hasWindowFunctionExpression());
//
// If we have no statement level order by or window functions,
// then we can't use this index for ordering, and we
// return 0.
//
if (! hasOrderBy && ! hasWindowFunctions) {
return 0;
}
//
// We make a definition. Let S1 and S2 be sequences of expressions,
// and OS be an increasing sequence of indices into S2. Let erase(S2, OS) be
// the sequence of expressions which results from erasing all S2
// expressions whose indices are in OS. We say *S1 is a prefix of
// S2 with OS-singular values* if S1 is a prefix of erase(S2, OS).
// That is to say, if we erase the expressions in S2 whose indices are
// in OS, S1 is a prefix of the result.
//
// What expressions must we match?
// 1.) We have the parameters indexedExpressions and indexedColRefs.
// These are the expressions or column references in an index.
// Exactly one of them is non-null. Since these are both an
// indexed sequence of expression-like things, denote the
// non-null one IS.
// What expressions do we care about? We have two kinds.
// 1.) The expressions from the statement level order by clause, OO.
// This sequence of expressions must be a prefix of IS with OS
// singular values for some sequence OS. The sequence OS will be
// called the order spoilers. Later on we will test that the
// index expressions at the positions in OS can have only a
// single value.
// 2.) The expressions in a window function's partition by list, WP,
// followed by the expressions in the window function's
// order by list, WO. The partition by functions are a set not
// a sequence. We need to find a sequence of expressions, S,
// such that S is a permutation of P and S+WO is a singular prefix
// of IS.
//
// So, in both cases, statement level order by and window function, we are looking for
// a sequence of expressions, S1, and a list of IS indices, OS, such
// that S1 is a prefix of IS with OS-singular values.
//
// If the statement level order by expression list is not a prefix of
// the index, we still care to know about window functions. The reverse
// is not true. If there are window functions but they all fail to match the index,
// we must give up on this index, even if the statement level order
// by list is still matching. This is because the window functions will
// require sorting before the statement level order by clause's
// sort, and this window function sort will invalidate the statement level
// order by sort.
//
// Note also that it's possible that the statement level order by and
// the window function order by are compatible. So this index may provide
// all the sorting needed.
//
// There need to be enough indexed expressions to provide full sort coverage.
// More indexed expressions are ok.
//
// We keep a scoreboard which keeps track of everything. All the window
// functions and statement level order by functions are kept in the scoreboard.
//
WindowFunctionScoreboard windowFunctionScores = new WindowFunctionScoreboard(m_parsedStmt, tableScan);
// indexCtr is an index into the index expressions or columns.
for (int indexCtr = 0; !windowFunctionScores.isDone() && indexCtr < keyComponentCount; indexCtr += 1) {
// Figure out what to do with index expression or column at indexCtr.
// First, fetch it out.
AbstractExpression indexExpr = (indexedExprs == null) ? null : indexedExprs.get(indexCtr);
ColumnRef indexColRef = (indexedColRefs == null) ? null : indexedColRefs.get(indexCtr);
// Then see if it matches something. If
// this doesn't match one thing it may match
// another. If it doesn't match anything, it may
// be an order spoiler, which we will maintain in
// the scoreboard.
windowFunctionScores.matchIndexEntry(new ExpressionOrColumn(indexCtr,
tableScan,
indexExpr,
SortDirectionType.INVALID,
indexColRef));
}
//
// The result is the number of order spoilers, but
// also the access path we have chosen, the order
// spoilers themselves and the bindings. Return these
// by reference.
//
return windowFunctionScores.getResult(retval, orderSpoilers, bindingsForOrder);
} | java |
private static List<AbstractExpression>
findBindingsForOneIndexedExpression(ExpressionOrColumn nextStatementEOC,
ExpressionOrColumn indexEntry) {
assert(nextStatementEOC.m_expr != null);
AbstractExpression nextStatementExpr = nextStatementEOC.m_expr;
if (indexEntry.m_colRef != null) {
ColumnRef indexColRef = indexEntry.m_colRef;
// This is a column. So try to match it
// with the expression in nextStatementEOC.
if (matchExpressionAndColumnRef(nextStatementExpr, indexColRef, indexEntry.m_tableScan)) {
return s_reusableImmutableEmptyBinding;
}
return null;
}
// So, this index entry is an expression.
List<AbstractExpression> moreBindings =
nextStatementEOC.m_expr.bindingToIndexedExpression(indexEntry.m_expr);
if (moreBindings != null) {
return moreBindings;
}
return null;
} | java |
private static boolean removeExactMatchCoveredExpressions(
AbstractExpression coveringExpr, List<AbstractExpression> exprsToCover) {
boolean hasMatch = false;
Iterator<AbstractExpression> iter = exprsToCover.iterator();
while(iter.hasNext()) {
AbstractExpression exprToCover = iter.next();
if (coveringExpr.bindingToIndexedExpression(exprToCover) != null) {
iter.remove();
hasMatch = true;
// need to keep going to remove all matches
}
}
return hasMatch;
} | java |
private static List<AbstractExpression> removeNotNullCoveredExpressions(StmtTableScan tableScan, List<AbstractExpression> coveringExprs, List<AbstractExpression> exprsToCover) {
// Collect all TVEs from NULL-rejecting covering expressions
Set<TupleValueExpression> coveringTves = new HashSet<>();
for (AbstractExpression coveringExpr : coveringExprs) {
if (ExpressionUtil.isNullRejectingExpression(coveringExpr, tableScan.getTableAlias())) {
coveringTves.addAll(ExpressionUtil.getTupleValueExpressions(coveringExpr));
}
}
// For each NOT NULL expression to cover extract the TVE expressions. If all of them are also part
// of the covering NULL-rejecting collection then this NOT NULL expression is covered
Iterator<AbstractExpression> iter = exprsToCover.iterator();
while (iter.hasNext()) {
AbstractExpression filter = iter.next();
if (ExpressionType.OPERATOR_NOT == filter.getExpressionType()) {
assert(filter.getLeft() != null);
if (ExpressionType.OPERATOR_IS_NULL == filter.getLeft().getExpressionType()) {
assert(filter.getLeft().getLeft() != null);
List<TupleValueExpression> tves = ExpressionUtil.getTupleValueExpressions(filter.getLeft().getLeft());
if (coveringTves.containsAll(tves)) {
iter.remove();
}
}
}
}
return exprsToCover;
} | java |
protected static AbstractPlanNode addSendReceivePair(AbstractPlanNode scanNode) {
SendPlanNode sendNode = new SendPlanNode();
sendNode.addAndLinkChild(scanNode);
ReceivePlanNode recvNode = new ReceivePlanNode();
recvNode.addAndLinkChild(sendNode);
return recvNode;
} | java |
protected static AbstractPlanNode getAccessPlanForTable(JoinNode tableNode) {
StmtTableScan tableScan = tableNode.getTableScan();
// Access path to access the data in the table (index/scan/etc).
AccessPath path = tableNode.m_currentAccessPath;
assert(path != null);
// if no index, it is a sequential scan
if (path.index == null) {
return getScanAccessPlanForTable(tableScan, path);
}
return getIndexAccessPlanForTable(tableScan, path);
} | java |
private static AbstractPlanNode getIndexAccessPlanForTable(
StmtTableScan tableScan, AccessPath path) {
// now assume this will be an index scan and get the relevant index
Index index = path.index;
IndexScanPlanNode scanNode = new IndexScanPlanNode(tableScan, index);
AbstractPlanNode resultNode = scanNode;
// set sortDirection here because it might be used for IN list
scanNode.setSortDirection(path.sortDirection);
// Build the list of search-keys for the index in question
// They are the rhs expressions of normalized indexExpr comparisons
// except for geo indexes. For geo indexes, the search key is directly
// the one element of indexExprs.
for (AbstractExpression expr : path.indexExprs) {
if (path.lookupType == IndexLookupType.GEO_CONTAINS) {
scanNode.addSearchKeyExpression(expr);
scanNode.addCompareNotDistinctFlag(false);
continue;
}
AbstractExpression exprRightChild = expr.getRight();
assert(exprRightChild != null);
if (expr.getExpressionType() == ExpressionType.COMPARE_IN) {
// Replace this method's result with an injected NLIJ.
resultNode = injectIndexedJoinWithMaterializedScan(exprRightChild, scanNode);
// Extract a TVE from the LHS MaterializedScan for use by the IndexScan in its new role.
MaterializedScanPlanNode matscan = (MaterializedScanPlanNode)resultNode.getChild(0);
AbstractExpression elemExpr = matscan.getOutputExpression();
assert(elemExpr != null);
// Replace the IN LIST condition in the end expression referencing all the list elements
// with a more efficient equality filter referencing the TVE for each element in turn.
replaceInListFilterWithEqualityFilter(path.endExprs, exprRightChild, elemExpr);
// Set up the similar VectorValue --> TVE replacement of the search key expression.
exprRightChild = elemExpr;
}
if (exprRightChild instanceof AbstractSubqueryExpression) {
// The AbstractSubqueryExpression must be wrapped up into a
// ScalarValueExpression which extracts the actual row/column from
// the subquery
// ENG-8175: this part of code seems not working for float/varchar type index ?!
// DEAD CODE with the guards on index: ENG-8203
assert(false);
}
scanNode.addSearchKeyExpression(exprRightChild);
// If the index expression is an "IS NOT DISTINCT FROM" comparison, let the NULL values go through. (ENG-11096)
scanNode.addCompareNotDistinctFlag(expr.getExpressionType() == ExpressionType.COMPARE_NOTDISTINCT);
}
// create the IndexScanNode with all its metadata
scanNode.setLookupType(path.lookupType);
scanNode.setBindings(path.bindings);
scanNode.setEndExpression(ExpressionUtil.combinePredicates(path.endExprs));
if (! path.index.getPredicatejson().isEmpty()) {
try {
scanNode.setPartialIndexPredicate(
AbstractExpression.fromJSONString(path.index.getPredicatejson(), tableScan));
} catch (JSONException e) {
throw new PlanningErrorException(e.getMessage(), 0);
}
}
scanNode.setPredicate(path.otherExprs);
// Propagate the sorting information
// into the scan node from the access path.
// The initial expression is needed to control a (short?) forward scan to adjust the start of a reverse
// iteration after it had to initially settle for starting at "greater than a prefix key".
scanNode.setInitialExpression(ExpressionUtil.combinePredicates(path.initialExpr));
scanNode.setSkipNullPredicate();
scanNode.setEliminatedPostFilters(path.eliminatedPostExprs);
final IndexUseForOrderBy indexUse = scanNode.indexUse();
indexUse.setWindowFunctionUsesIndex(path.m_windowFunctionUsesIndex);
indexUse.setSortOrderFromIndexScan(path.sortDirection);
indexUse.setWindowFunctionIsCompatibleWithOrderBy(path.m_stmtOrderByIsCompatible);
indexUse.setFinalExpressionOrderFromIndexScan(path.m_finalExpressionOrder);
return resultNode;
} | java |
private static AbstractPlanNode injectIndexedJoinWithMaterializedScan(
AbstractExpression listElements, IndexScanPlanNode scanNode) {
MaterializedScanPlanNode matScan = new MaterializedScanPlanNode();
assert(listElements instanceof VectorValueExpression || listElements instanceof ParameterValueExpression);
matScan.setRowData(listElements);
matScan.setSortDirection(scanNode.getSortDirection());
NestLoopIndexPlanNode nlijNode = new NestLoopIndexPlanNode();
nlijNode.setJoinType(JoinType.INNER);
nlijNode.addInlinePlanNode(scanNode);
nlijNode.addAndLinkChild(matScan);
// resolve the sort direction
nlijNode.resolveSortDirection();
return nlijNode;
} | java |
private static void replaceInListFilterWithEqualityFilter(List<AbstractExpression> endExprs,
AbstractExpression inListRhs,
AbstractExpression equalityRhs)
{
for (AbstractExpression comparator : endExprs) {
AbstractExpression otherExpr = comparator.getRight();
if (otherExpr == inListRhs) {
endExprs.remove(comparator);
AbstractExpression replacement =
new ComparisonExpression(ExpressionType.COMPARE_EQUAL,
comparator.getLeft(),
equalityRhs);
endExprs.add(replacement);
break;
}
}
} | java |
CallEvent[] makeRandomEvent() {
long callId = ++lastCallIdUsed;
// get agentid
Integer agentId = agentsAvailable.poll();
if (agentId == null) {
return null;
}
// get phone number
Long phoneNo = phoneNumbersAvailable.poll();
assert(phoneNo != null);
// voltdb timestamp type uses micros from epoch
Date startTS = new Date(currentSystemMilliTimestamp);
long durationms = -1;
long meancalldurationms = config.meancalldurationseconds * 1000;
long maxcalldurationms = config.maxcalldurationseconds * 1000;
double stddev = meancalldurationms / 2.0;
// repeat until in the range (0..maxcalldurationms]
while ((durationms <= 0) || (durationms > maxcalldurationms)) {
durationms = (long) (rand.nextGaussian() * stddev) + meancalldurationms;
}
Date endTS = new Date(startTS.getTime() + durationms);
CallEvent[] event = new CallEvent[2];
event[0] = new CallEvent(callId, agentId, phoneNo, startTS, null);
event[1] = new CallEvent(callId, agentId, phoneNo, null, endTS);
// some debugging code
//System.out.println("Creating event with range:");
//System.out.println(new Date(startTS.getTime() / 1000));
//System.out.println(new Date(endTS.getTime() / 1000));
return event;
} | java |
@Override
public CallEvent next(long systemCurrentTimeMillis) {
// check for time passing
if (systemCurrentTimeMillis > currentSystemMilliTimestamp) {
// build a target for this 1ms window
long eventBacklog = targetEventsThisMillisecond - eventsSoFarThisMillisecond;
targetEventsThisMillisecond = (long) Math.floor(targetEventsPerMillisecond);
double targetFraction = targetEventsPerMillisecond - targetEventsThisMillisecond;
targetEventsThisMillisecond += (rand.nextDouble() <= targetFraction) ? 1 : 0;
targetEventsThisMillisecond += eventBacklog;
// reset counter for this 1ms window
eventsSoFarThisMillisecond = 0;
currentSystemMilliTimestamp = systemCurrentTimeMillis;
}
// drain scheduled events first
CallEvent callEvent = delayedEvents.nextReady(systemCurrentTimeMillis);
if (callEvent != null) {
// double check this is an end event
assert(callEvent.startTS == null);
assert(callEvent.endTS != null);
// return the agent/phone for this event to the available lists
agentsAvailable.add(callEvent.agentId);
phoneNumbersAvailable.add(callEvent.phoneNo);
validate();
return callEvent;
}
// check if we made all the target events for this 1ms window
if (targetEventsThisMillisecond == eventsSoFarThisMillisecond) {
validate();
return null;
}
// generate rando event (begin/end pair)
CallEvent[] event = makeRandomEvent();
// this means all agents are busy
if (event == null) {
validate();
return null;
}
// schedule the end event
long endTimeKey = event[1].endTS.getTime();
assert((endTimeKey - systemCurrentTimeMillis) < (config.maxcalldurationseconds * 1000));
delayedEvents.add(endTimeKey, event[1]);
eventsSoFarThisMillisecond++;
validate();
return event[0];
} | java |
private void validate() {
long delayedEventCount = delayedEvents.size();
long outstandingAgents = config.agents - agentsAvailable.size();
long outstandingPhones = config.numbers - phoneNumbersAvailable.size();
if (outstandingAgents != outstandingPhones) {
throw new RuntimeException(
String.format("outstandingAgents (%d) != outstandingPhones (%d)",
outstandingAgents, outstandingPhones));
}
if (outstandingAgents != delayedEventCount) {
throw new RuntimeException(
String.format("outstandingAgents (%d) != delayedEventCount (%d)",
outstandingAgents, delayedEventCount));
}
} | java |
void printSummary() {
System.out.printf("There are %d agents outstanding and %d phones. %d entries waiting to go.\n",
agentsAvailable.size(), phoneNumbersAvailable.size(), delayedEvents.size());
} | java |
private boolean isNegativeNumber(String token)
{
try
{
Double.parseDouble(token);
return true;
}
catch (NumberFormatException e)
{
return false;
}
} | java |
private boolean isLongOption(String token)
{
if (!token.startsWith("-") || token.length() == 1)
{
return false;
}
int pos = token.indexOf("=");
String t = pos == -1 ? token : token.substring(0, pos);
if (!options.getMatchingOptions(t).isEmpty())
{
// long or partial long options (--L, -L, --L=V, -L=V, --l, --l=V)
return true;
}
else if (getLongPrefix(token) != null && !token.startsWith("--"))
{
// -LV
return true;
}
return false;
} | java |
private void handleUnknownToken(String token) throws ParseException
{
if (token.startsWith("-") && token.length() > 1 && !stopAtNonOption)
{
throw new UnrecognizedOptionException("Unrecognized option: " + token, token);
}
cmd.addArg(token);
if (stopAtNonOption)
{
skipParsing = true;
}
} | java |
public String getText() {
if (sqlTextStr == null) {
sqlTextStr = new String(sqlText, Constants.UTF8ENCODING);
}
return sqlTextStr;
} | java |
public static String canonicalizeStmt(String stmtStr) {
// Cleanup whitespace newlines and adding semicolon for catalog compatibility
stmtStr = stmtStr.replaceAll("\n", " ");
stmtStr = stmtStr.trim();
if (!stmtStr.endsWith(";")) {
stmtStr += ";";
}
return stmtStr;
} | java |
private static boolean[] createSafeOctets(String safeChars) {
int maxChar = -1;
char[] safeCharArray = safeChars.toCharArray();
for (char c : safeCharArray) {
maxChar = Math.max(c, maxChar);
}
boolean[] octets = new boolean[maxChar + 1];
for (char c : safeCharArray) {
octets[c] = true;
}
return octets;
} | java |
String getTableName() {
if (opType == OpTypes.MULTICOLUMN) {
return tableName;
}
if (opType == OpTypes.COLUMN) {
if (rangeVariable == null) {
return tableName;
}
return rangeVariable.getTable().getName().name;
}
return "";
} | java |
VoltXMLElement voltAnnotateColumnXML(VoltXMLElement exp) {
if (tableName != null) {
if (rangeVariable != null && rangeVariable.rangeTable != null &&
rangeVariable.tableAlias != null &&
rangeVariable.rangeTable.tableType == TableBase.SYSTEM_SUBQUERY) {
exp.attributes.put("table", rangeVariable.tableAlias.name.toUpperCase());
}
else {
exp.attributes.put("table", tableName.toUpperCase());
}
}
exp.attributes.put("column", columnName.toUpperCase());
if ((alias == null) || (getAlias().length() == 0)) {
exp.attributes.put("alias", columnName.toUpperCase());
}
if (rangeVariable != null && rangeVariable.tableAlias != null) {
exp.attributes.put("tablealias", rangeVariable.tableAlias.name.toUpperCase());
}
exp.attributes.put("index", Integer.toString(columnIndex));
return exp;
} | java |
void parseTablesAndParams(VoltXMLElement root) {
// Parse parameters first to satisfy a dependency of expression parsing
// which happens during table scan parsing.
parseParameters(root);
parseCommonTableExpressions(root);
for (VoltXMLElement node : root.children) {
if (node.name.equalsIgnoreCase("tablescan")) {
parseTable(node);
}
else if (node.name.equalsIgnoreCase("tablescans")) {
parseTables(node);
}
}
} | java |
private AbstractExpression parseExpressionNode(VoltXMLElement exprNode) {
String elementName = exprNode.name.toLowerCase();
XMLElementExpressionParser parser = m_exprParsers.get(elementName);
if (parser == null) {
throw new PlanningErrorException("Unsupported expression node '" + elementName + "'");
}
AbstractExpression retval = parser.parse(this, exprNode);
assert("asterisk".equals(elementName) || retval != null);
return retval;
} | java |
private AbstractExpression parseVectorExpression(VoltXMLElement exprNode) {
ArrayList<AbstractExpression> args = new ArrayList<>();
for (VoltXMLElement argNode : exprNode.children) {
assert(argNode != null);
// recursively parse each argument subtree (could be any kind of expression).
AbstractExpression argExpr = parseExpressionNode(argNode);
assert(argExpr != null);
args.add(argExpr);
}
VectorValueExpression vve = new VectorValueExpression();
vve.setValueType(VoltType.VOLTTABLE);
vve.setArgs(args);
return vve;
} | java |
private SelectSubqueryExpression parseSubqueryExpression(VoltXMLElement exprNode) {
assert(exprNode.children.size() == 1);
VoltXMLElement subqueryElmt = exprNode.children.get(0);
AbstractParsedStmt subqueryStmt = parseSubquery(subqueryElmt);
// add table to the query cache
String withoutAlias = null;
StmtSubqueryScan stmtSubqueryScan =
addSubqueryToStmtCache(subqueryStmt, withoutAlias);
// Set to the default SELECT_SUBQUERY. May be overridden depending on the context
return new SelectSubqueryExpression(ExpressionType.SELECT_SUBQUERY, stmtSubqueryScan);
} | java |
private StmtTableScan resolveStmtTableScanByAlias(String tableAlias) {
StmtTableScan tableScan = getStmtTableScanByAlias(tableAlias);
if (tableScan != null) {
return tableScan;
}
if (m_parentStmt != null) {
// This may be a correlated subquery
return m_parentStmt.resolveStmtTableScanByAlias(tableAlias);
}
return null;
} | java |
protected StmtTableScan addTableToStmtCache(Table table, String tableAlias) {
// Create an index into the query Catalog cache
StmtTableScan tableScan = m_tableAliasMap.get(tableAlias);
if (tableScan == null) {
tableScan = new StmtTargetTableScan(table, tableAlias, m_stmtId);
m_tableAliasMap.put(tableAlias, tableScan);
}
return tableScan;
} | java |
protected StmtSubqueryScan addSubqueryToStmtCache(
AbstractParsedStmt subquery, String tableAlias) {
assert(subquery != null);
// If there is no usable alias because the subquery is inside an expression,
// generate a unique one for internal use.
if (tableAlias == null) {
tableAlias = AbstractParsedStmt.TEMP_TABLE_NAME + "_" + subquery.m_stmtId;
}
StmtSubqueryScan subqueryScan =
new StmtSubqueryScan(subquery, tableAlias, m_stmtId);
StmtTableScan prior = m_tableAliasMap.put(tableAlias, subqueryScan);
assert(prior == null);
return subqueryScan;
} | java |
private StmtTargetTableScan addSimplifiedSubqueryToStmtCache(
StmtSubqueryScan subqueryScan, StmtTargetTableScan tableScan) {
String tableAlias = subqueryScan.getTableAlias();
assert(tableAlias != null);
// It is guaranteed by the canSimplifySubquery that there is
// one and only one TABLE in the subquery's FROM clause.
Table promotedTable = tableScan.getTargetTable();
StmtTargetTableScan promotedScan =
new StmtTargetTableScan(promotedTable, tableAlias, m_stmtId);
// Keep the original subquery scan to be able to tie the parent
// statement column/table names and aliases to the table's.
promotedScan.setOriginalSubqueryScan(subqueryScan);
// Replace the subquery scan with the table scan
StmtTableScan prior = m_tableAliasMap.put(tableAlias, promotedScan);
assert(prior == subqueryScan);
m_tableList.add(promotedTable);
return promotedScan;
} | java |
protected AbstractExpression replaceExpressionsWithPve(AbstractExpression expr) {
assert(expr != null);
if (expr instanceof TupleValueExpression) {
int paramIdx = ParameterizationInfo.getNextParamIndex();
ParameterValueExpression pve = new ParameterValueExpression(paramIdx, expr);
m_parameterTveMap.put(paramIdx, expr);
return pve;
}
if (expr instanceof AggregateExpression) {
int paramIdx = ParameterizationInfo.getNextParamIndex();
ParameterValueExpression pve = new ParameterValueExpression(paramIdx, expr);
// Disallow aggregation of parent columns in a subquery.
// except the case HAVING AGG(T1.C1) IN (SELECT T2.C2 ...)
List<TupleValueExpression> tves = ExpressionUtil.getTupleValueExpressions(expr);
assert(m_parentStmt != null);
for (TupleValueExpression tve : tves) {
int origId = tve.getOrigStmtId();
if (m_stmtId != origId && m_parentStmt.m_stmtId != origId) {
throw new PlanningErrorException(
"Subqueries do not support aggregation of parent statement columns");
}
}
m_parameterTveMap.put(paramIdx, expr);
return pve;
}
if (expr.getLeft() != null) {
expr.setLeft(replaceExpressionsWithPve(expr.getLeft()));
}
if (expr.getRight() != null) {
expr.setRight(replaceExpressionsWithPve(expr.getRight()));
}
if (expr.getArgs() != null) {
List<AbstractExpression> newArgs = new ArrayList<>();
for (AbstractExpression argument : expr.getArgs()) {
newArgs.add(replaceExpressionsWithPve(argument));
}
expr.setArgs(newArgs);
}
return expr;
} | java |
private StmtCommonTableScan resolveCommonTableByName(String tableName, String tableAlias) {
StmtCommonTableScan answer = null;
StmtCommonTableScanShared scan = null;
for (AbstractParsedStmt scope = this; scope != null && scan == null; scope = scope.getParentStmt()) {
scan = scope.getCommonTableByName(tableName);
}
if (scan != null) {
answer = new StmtCommonTableScan(tableName, tableAlias, scan);
}
return answer;
} | java |
protected void parseParameters(VoltXMLElement root) {
VoltXMLElement paramsNode = null;
for (VoltXMLElement node : root.children) {
if (node.name.equalsIgnoreCase("parameters")) {
paramsNode = node;
break;
}
}
if (paramsNode == null) {
return;
}
for (VoltXMLElement node : paramsNode.children) {
if (node.name.equalsIgnoreCase("parameter")) {
long id = Long.parseLong(node.attributes.get("id"));
String typeName = node.attributes.get("valuetype");
String isVectorParam = node.attributes.get("isvector");
// Get the index for this parameter in the EE's parameter vector
String indexAttr = node.attributes.get("index");
assert(indexAttr != null);
int index = Integer.parseInt(indexAttr);
VoltType type = VoltType.typeFromString(typeName);
ParameterValueExpression pve = new ParameterValueExpression();
pve.setParameterIndex(index);
pve.setValueType(type);
if (isVectorParam != null && isVectorParam.equalsIgnoreCase("true")) {
pve.setParamIsVector();
}
m_paramsById.put(id, pve);
getParamsByIndex().put(index, pve);
}
}
} | java |
protected void promoteUnionParametersFromChild(AbstractParsedStmt childStmt) {
getParamsByIndex().putAll(childStmt.getParamsByIndex());
m_parameterTveMap.putAll(childStmt.m_parameterTveMap);
} | java |
HashMap<AbstractExpression, Set<AbstractExpression>> analyzeValueEquivalence() {
// collect individual where/join expressions
m_joinTree.analyzeJoinExpressions(m_noTableSelectionList);
return m_joinTree.getAllEquivalenceFilters();
} | java |
protected Table getTableFromDB(String tableName) {
Table table = m_db.getTables().getExact(tableName);
return table;
} | java |
private AbstractExpression parseTableCondition(VoltXMLElement tableScan,
String joinOrWhere) {
AbstractExpression condExpr = null;
for (VoltXMLElement childNode : tableScan.children) {
if ( ! childNode.name.equalsIgnoreCase(joinOrWhere)) {
continue;
}
assert(childNode.children.size() == 1);
assert(condExpr == null);
condExpr = parseConditionTree(childNode.children.get(0));
assert(condExpr != null);
ExpressionUtil.finalizeValueTypes(condExpr);
condExpr = ExpressionUtil.evaluateExpression(condExpr);
// If the condition is a trivial CVE(TRUE) (after the evaluation) simply drop it
if (ConstantValueExpression.isBooleanTrue(condExpr)) {
condExpr = null;
}
}
return condExpr;
} | java |
LimitPlanNode limitPlanNodeFromXml(VoltXMLElement limitXml, VoltXMLElement offsetXml) {
if (limitXml == null && offsetXml == null) {
return null;
}
String node;
long limitParameterId = -1;
long offsetParameterId = -1;
long limit = -1;
long offset = 0;
if (limitXml != null) {
// Parse limit
if ((node = limitXml.attributes.get("limit_paramid")) != null) {
limitParameterId = Long.parseLong(node);
}
else {
assert(limitXml.children.size() == 1);
VoltXMLElement valueNode = limitXml.children.get(0);
String isParam = valueNode.attributes.get("isparam");
if ((isParam != null) && (isParam.equalsIgnoreCase("true"))) {
limitParameterId = Long.parseLong(valueNode.attributes.get("id"));
}
else {
node = limitXml.attributes.get("limit");
assert(node != null);
limit = Long.parseLong(node);
}
}
}
if (offsetXml != null) {
// Parse offset
if ((node = offsetXml.attributes.get("offset_paramid")) != null) {
offsetParameterId = Long.parseLong(node);
}
else {
if (offsetXml.children.size() == 1) {
VoltXMLElement valueNode = offsetXml.children.get(0);
String isParam = valueNode.attributes.get("isparam");
if ((isParam != null) && (isParam.equalsIgnoreCase("true"))) {
offsetParameterId = Long.parseLong(valueNode.attributes.get("id"));
}
else {
node = offsetXml.attributes.get("offset");
assert(node != null);
offset = Long.parseLong(node);
}
}
}
}
// limit and offset can't have both value and parameter
if (limit != -1) assert limitParameterId == -1 : "Parsed value and param. limit.";
if (offset != 0) assert offsetParameterId == -1 : "Parsed value and param. offset.";
LimitPlanNode limitPlanNode = new LimitPlanNode();
limitPlanNode.setLimit((int) limit);
limitPlanNode.setOffset((int) offset);
limitPlanNode.setLimitParameterIndex(parameterCountIndexById(limitParameterId));
limitPlanNode.setOffsetParameterIndex(parameterCountIndexById(offsetParameterId));
return limitPlanNode;
} | java |
protected boolean orderByColumnsCoverUniqueKeys() {
// In theory, if EVERY table in the query has a uniqueness constraint
// (primary key or other unique index) on columns that are all listed in the ORDER BY values,
// the result is deterministic.
// This holds regardless of whether the associated index is actually used in the selected plan,
// so this check is plan-independent.
//
// baseTableAliases associates table aliases with the order by
// expressions which reference them. Presumably by using
// table aliases we will map table scans to expressions rather
// than tables to expressions, and not confuse ourselves with
// different instances of the same table in self joins.
HashMap<String, List<AbstractExpression> > baseTableAliases =
new HashMap<>();
for (ParsedColInfo col : orderByColumns()) {
AbstractExpression expr = col.m_expression;
//
// Compute the set of tables mentioned in the expression.
// 1. Search out all the TVEs.
// 2. Throw the aliases of the tables of each of these into a HashSet.
// The table must have an alias. It might not have a name.
// 3. If the HashSet has size > 1 we can't use this expression.
//
List<TupleValueExpression> baseTVEExpressions =
expr.findAllTupleValueSubexpressions();
Set<String> baseTableNames = new HashSet<>();
for (TupleValueExpression tve : baseTVEExpressions) {
String tableAlias = tve.getTableAlias();
assert(tableAlias != null);
baseTableNames.add(tableAlias);
}
if (baseTableNames.size() != 1) {
// Table-spanning ORDER BYs -- like ORDER BY A.X + B.Y are not helpful.
// Neither are (nonsense) constant (table-less) expressions.
continue;
}
// Everything in the baseTVEExpressions table is a column
// in the same table and has the same alias. So just grab the first one.
// All we really want is the alias.
AbstractExpression baseTVE = baseTVEExpressions.get(0);
String nextTableAlias = ((TupleValueExpression)baseTVE).getTableAlias();
// This was tested above. But the assert above may prove to be over cautious
// and disappear.
assert(nextTableAlias != null);
List<AbstractExpression> perTable = baseTableAliases.get(nextTableAlias);
if (perTable == null) {
perTable = new ArrayList<>();
baseTableAliases.put(nextTableAlias, perTable);
}
perTable.add(expr);
}
if (m_tableAliasMap.size() > baseTableAliases.size()) {
// FIXME: There are more table aliases in the select list than tables
// named in the order by clause. So, some tables named in the
// select list are not explicitly listed in the order by
// clause.
//
// This would be one of the tricky cases where the goal would be to prove that the
// row with no ORDER BY component came from the right side of a 1-to-1 or many-to-1 join.
// like Unique Index nested loop join, etc.
return false;
}
boolean allScansAreDeterministic = true;
for (Entry<String, List<AbstractExpression>> orderedAlias : baseTableAliases.entrySet()) {
List<AbstractExpression> orderedAliasExprs = orderedAlias.getValue();
StmtTableScan tableScan = getStmtTableScanByAlias(orderedAlias.getKey());
if (tableScan == null) {
assert(false);
return false;
}
if (tableScan instanceof StmtSubqueryScan) {
return false; // don't yet handle FROM clause subquery, here.
}
Table table = ((StmtTargetTableScan)tableScan).getTargetTable();
// This table's scans need to be proven deterministic.
allScansAreDeterministic = false;
// Search indexes for one that makes the order by deterministic
for (Index index : table.getIndexes()) {
// skip non-unique indexes
if ( ! index.getUnique()) {
continue;
}
// get the list of expressions for the index
List<AbstractExpression> indexExpressions = new ArrayList<>();
String jsonExpr = index.getExpressionsjson();
// if this is a pure-column index...
if (jsonExpr.isEmpty()) {
for (ColumnRef cref : index.getColumns()) {
Column col = cref.getColumn();
TupleValueExpression tve = new TupleValueExpression(table.getTypeName(),
orderedAlias.getKey(),
col.getName(),
col.getName(),
col.getIndex());
indexExpressions.add(tve);
}
}
// if this is a fancy expression-based index...
else {
try {
indexExpressions = AbstractExpression.fromJSONArrayString(jsonExpr, tableScan);
}
catch (JSONException e) {
e.printStackTrace();
assert(false);
continue;
}
}
// If the sort covers the index, then it's a unique sort.
// TODO: The statement's equivalence sets would be handy here to recognize cases like
// WHERE B.unique_id = A.b_id
// ORDER BY A.unique_id, A.b_id
if (orderedAliasExprs.containsAll(indexExpressions)) {
allScansAreDeterministic = true;
break;
}
}
// ALL tables' scans need to have proved deterministic
if ( ! allScansAreDeterministic) {
return false;
}
}
return true;
} | java |
protected void addHonoraryOrderByExpressions(
HashSet<AbstractExpression> orderByExprs,
List<ParsedColInfo> candidateColumns) {
// If there is not exactly one table scan we will not proceed.
// We don't really know how to make indices work with joins,
// and there is nothing more to do with subqueries. The processing
// of joins is the content of ticket ENG-8677.
if (m_tableAliasMap.size() != 1) {
return;
}
HashMap<AbstractExpression, Set<AbstractExpression>> valueEquivalence =
analyzeValueEquivalence();
for (ParsedColInfo colInfo : candidateColumns) {
AbstractExpression colExpr = colInfo.m_expression;
if (colExpr instanceof TupleValueExpression) {
Set<AbstractExpression> tveEquivs = valueEquivalence.get(colExpr);
if (tveEquivs != null) {
for (AbstractExpression expr : tveEquivs) {
if (expr instanceof ParameterValueExpression
|| expr instanceof ConstantValueExpression) {
orderByExprs.add(colExpr);
}
}
}
}
}
// We know there's exactly one.
StmtTableScan scan = m_tableAliasMap.values().iterator().next();
// Get the table. There's only one.
Table table = getTableFromDB(scan.getTableName());
// Maybe this is a subquery? If we can't find the table
// there's no use to continue.
if (table == null) {
return;
}
// Now, look to see if there is a constraint which can help us.
// If there is a unique constraint on a set of columns, and all
// the constrained columns are in the order by list, then all
// the columns in the table can be added to the order by list.
//
// The indices we care about have columns, but the order by list has expressions.
// Extract the columns from the order by list.
Set<Column> orderByColumns = new HashSet<>();
for (AbstractExpression expr : orderByExprs) {
if (expr instanceof TupleValueExpression) {
TupleValueExpression tve = (TupleValueExpression) expr;
Column col = table.getColumns().get(tve.getColumnName());
orderByColumns.add(col);
}
}
CatalogMap<Constraint> constraints = table.getConstraints();
// If we have no constraints, there's nothing more to do here.
if (constraints == null) {
return;
}
Set<Index> indices = new HashSet<>();
for (Constraint constraint : constraints) {
Index index = constraint.getIndex();
// Only use column indices for now.
if (index != null && index.getUnique() && index.getExpressionsjson().isEmpty()) {
indices.add(index);
}
}
for (ParsedColInfo colInfo : candidateColumns) {
AbstractExpression expr = colInfo.m_expression;
if (expr instanceof TupleValueExpression) {
TupleValueExpression tve = (TupleValueExpression) expr;
// If one of the indices is completely covered
// we will not have to process any other indices.
// So, we remember this and early-out.
for (Index index : indices) {
CatalogMap<ColumnRef> columns = index.getColumns();
// If all the columns in this index are in the current
// honorary order by list, then we can add all the
// columns in this table to the honorary order by list.
boolean addAllColumns = true;
for (ColumnRef cr : columns) {
Column col = cr.getColumn();
if (orderByColumns.contains(col) == false) {
addAllColumns = false;
break;
}
}
if (addAllColumns) {
for (Column addCol : table.getColumns()) {
// We have to convert this to a TVE to add
// it to the orderByExprs. We will use -1
// for the column index. We don't have a column
// alias.
TupleValueExpression ntve = new TupleValueExpression(tve.getTableName(),
tve.getTableAlias(),
addCol.getName(),
null,
-1);
orderByExprs.add(ntve);
}
// Don't forget to remember to forget the other indices. (E. Presley, 1955)
break;
}
}
}
}
} | java |
protected boolean producesOneRowOutput () {
if (m_tableAliasMap.size() != 1) {
return false;
}
// Get the table. There's only one.
StmtTableScan scan = m_tableAliasMap.values().iterator().next();
Table table = getTableFromDB(scan.getTableName());
// May be sub-query? If can't find the table there's no use to continue.
if (table == null) {
return false;
}
// Get all the indexes defined on the table
CatalogMap<Index> indexes = table.getIndexes();
if (indexes == null || indexes.size() == 0) {
// no indexes defined on the table
return false;
}
// Collect value equivalence expression for the SQL statement
HashMap<AbstractExpression, Set<AbstractExpression>> valueEquivalence = analyzeValueEquivalence();
// If no value equivalence filter defined in SQL statement, there's no use to continue
if (valueEquivalence.isEmpty()) {
return false;
}
// Collect all tve expressions from value equivalence set which have equivalence
// defined to parameterized or constant value expression.
// Eg: T.A = ? or T.A = 1
Set <AbstractExpression> parameterizedConstantKeys = new HashSet<>();
Set<AbstractExpression> valueEquivalenceKeys = valueEquivalence.keySet(); // get all the keys
for (AbstractExpression key : valueEquivalenceKeys) {
if (key instanceof TupleValueExpression) {
Set<AbstractExpression> values = valueEquivalence.get(key);
for (AbstractExpression value : values) {
if ((value instanceof ParameterValueExpression) ||
(value instanceof ConstantValueExpression)) {
TupleValueExpression tve = (TupleValueExpression) key;
parameterizedConstantKeys.add(tve);
}
}
}
}
// Iterate over the unique indexes defined on the table to check if the unique
// index defined on table appears in tve equivalence expression gathered above.
for (Index index : indexes) {
// Perform lookup only on pure column indices which are unique
if (!index.getUnique() || !index.getExpressionsjson().isEmpty()) {
continue;
}
Set<AbstractExpression> indexExpressions = new HashSet<>();
CatalogMap<ColumnRef> indexColRefs = index.getColumns();
for (ColumnRef indexColRef:indexColRefs) {
Column col = indexColRef.getColumn();
TupleValueExpression tve = new TupleValueExpression(scan.getTableName(),
scan.getTableAlias(),
col.getName(),
col.getName(),
col.getIndex());
indexExpressions.add(tve);
}
if (parameterizedConstantKeys.containsAll(indexExpressions)) {
return true;
}
}
return false;
} | java |
public Collection<String> calculateUDFDependees() {
List<String> answer = new ArrayList<>();
Collection<AbstractExpression> fCalls = findAllSubexpressionsOfClass(FunctionExpression.class);
for (AbstractExpression fCall : fCalls) {
FunctionExpression fexpr = (FunctionExpression)fCall;
if (fexpr.isUserDefined()) {
answer.add(fexpr.getFunctionName());
}
}
return answer;
} | java |
public void statementGuaranteesDeterminism(boolean hasLimitOrOffset,
boolean order,
String contentDeterminismDetail) {
m_statementHasLimitOrOffset = hasLimitOrOffset;
m_statementIsOrderDeterministic = order;
if (contentDeterminismDetail != null) {
m_contentDeterminismDetail = contentDeterminismDetail;
}
} | java |
private static void setParamIndexes(BitSet ints, List<AbstractExpression> params) {
for(AbstractExpression ae : params) {
assert(ae instanceof ParameterValueExpression);
ParameterValueExpression pve = (ParameterValueExpression) ae;
int param = pve.getParameterIndex();
ints.set(param);
}
} | java |
private static int[] bitSetToIntVector(BitSet ints) {
int intCount = ints.cardinality();
if (intCount == 0) {
return null;
}
int[] result = new int[intCount];
int nextBit = ints.nextSetBit(0);
for (int ii = 0; ii < intCount; ii++) {
assert(nextBit != -1);
result[ii] = nextBit;
nextBit = ints.nextSetBit(nextBit+1);
}
assert(nextBit == -1);
return result;
} | java |
public VoltType[] parameterTypes() {
if (m_parameterTypes == null) {
m_parameterTypes = new VoltType[getParameters().length];
int ii = 0;
for (ParameterValueExpression param : getParameters()) {
m_parameterTypes[ii++] = param.getValueType();
}
}
return m_parameterTypes;
} | java |
public static Session newSession(int dbID, String user, String password,
int timeZoneSeconds) {
Database db = (Database) databaseIDMap.get(dbID);
if (db == null) {
return null;
}
Session session = db.connect(user, password, timeZoneSeconds);
session.isNetwork = true;
return session;
} | java |
public static Session newSession(String type, String path, String user,
String password, HsqlProperties props,
int timeZoneSeconds) {
Database db = getDatabase(type, path, props);
if (db == null) {
return null;
}
return db.connect(user, password, timeZoneSeconds);
} | java |
public static synchronized Database lookupDatabaseObject(String type,
String path) {
// A VoltDB extension to work around ENG-6044
/* disabled 14 lines ...
Object key = path;
HashMap databaseMap;
if (type == DatabaseURL.S_FILE) {
databaseMap = fileDatabaseMap;
key = filePathToKey(path);
} else if (type == DatabaseURL.S_RES) {
databaseMap = resDatabaseMap;
} else if (type == DatabaseURL.S_MEM) {
databaseMap = memDatabaseMap;
} else {
throw (Error.runtimeError(
ErrorCode.U_S0500, "DatabaseManager.lookupDatabaseObject()"));
}
... disabled 14 lines */
assert (type == DatabaseURL.S_MEM);
java.util.HashMap<String, Database> databaseMap = memDatabaseMap;
String key = path;
// End of VoltDB extension
return (Database) databaseMap.get(key);
} | java |
private static synchronized void addDatabaseObject(String type,
String path, Database db) {
// A VoltDB extension to work around ENG-6044
/* disable 15 lines ...
Object key = path;
HashMap databaseMap;
if (type == DatabaseURL.S_FILE) {
databaseMap = fileDatabaseMap;
key = filePathToKey(path);
} else if (type == DatabaseURL.S_RES) {
databaseMap = resDatabaseMap;
} else if (type == DatabaseURL.S_MEM) {
databaseMap = memDatabaseMap;
} else {
throw Error.runtimeError(ErrorCode.U_S0500,
"DatabaseManager.addDatabaseObject()");
}
... disabled 15 lines */
assert(type == DatabaseURL.S_MEM);
java.util.HashMap<String, Database> databaseMap = memDatabaseMap;
String key = path;
// End of VoltDB extension
databaseIDMap.put(db.databaseID, db);
databaseMap.put(key, db);
} | java |
static void removeDatabase(Database database) {
int dbID = database.databaseID;
String type = database.getType();
String path = database.getPath();
// A VoltDB extension to work around ENG-6044
/* disable 2 lines ...
Object key = path;
HashMap databaseMap;
... disabled 2 lines */
// End of VoltDB extension
notifyServers(database);
// A VoltDB extension to work around ENG-6044
/* disable 11 lines ...
if (type == DatabaseURL.S_FILE) {
databaseMap = fileDatabaseMap;
key = filePathToKey(path);
} else if (type == DatabaseURL.S_RES) {
databaseMap = resDatabaseMap;
} else if (type == DatabaseURL.S_MEM) {
databaseMap = memDatabaseMap;
} else {
throw (Error.runtimeError(
ErrorCode.U_S0500, "DatabaseManager.lookupDatabaseObject()"));
}
... disabled 11 lines */
assert(type == DatabaseURL.S_MEM);
java.util.HashMap<String, Database> databaseMap = memDatabaseMap;
String key = path;
// End of VoltDB extension
databaseIDMap.remove(dbID);
databaseMap.remove(key);
if (databaseIDMap.isEmpty()) {
ValuePool.resetPool();
}
} | java |
private static void deRegisterServer(Server server, Database db) {
Iterator it = serverMap.values().iterator();
for (; it.hasNext(); ) {
HashSet databases = (HashSet) it.next();
databases.remove(db);
if (databases.isEmpty()) {
it.remove();
}
}
} | java |
private static void registerServer(Server server, Database db) {
if (!serverMap.containsKey(server)) {
serverMap.put(server, new HashSet());
}
HashSet databases = (HashSet) serverMap.get(server);
databases.add(db);
} | java |
private static void notifyServers(Database db) {
Iterator it = serverMap.keySet().iterator();
for (; it.hasNext(); ) {
Server server = (Server) it.next();
HashSet databases = (HashSet) serverMap.get(server);
if (databases.contains(db)) {
// A VoltDB extension to disable a package dependency
/* disable 2 lines ...
server.notify(ServerConstants.SC_DATABASE_SHUTDOWN,
db.databaseID);
... disabled 2 lines */
// End of VoltDB extension
}
}
} | java |
private static String filePathToKey(String path) {
try {
return FileUtil.getDefaultInstance().canonicalPath(path);
} catch (Exception e) {
return path;
}
} | java |
public static boolean isComment(String sql)
{
Matcher commentMatcher = PAT_SINGLE_LINE_COMMENT.matcher(sql);
return commentMatcher.matches();
} | java |
public static String extractDDLToken(String sql)
{
String ddlToken = null;
Matcher ddlMatcher = PAT_ANY_DDL_FIRST_TOKEN.matcher(sql);
if (ddlMatcher.find()) {
ddlToken = ddlMatcher.group(1).toLowerCase();
}
return ddlToken;
} | java |
public static String extractDDLTableName(String sql)
{
Matcher matcher = PAT_TABLE_DDL_PREAMBLE.matcher(sql);
if (matcher.find()) {
return matcher.group(2).toLowerCase();
}
return null;
} | java |
public static String checkPermitted(String sql)
{
/*
* IMPORTANT: Black-lists are checked first because they know more about
* what they don't like about a statement and can provide a better message.
* It requires that black-lists patterns be very selective and that they
* don't mind seeing statements that wouldn't pass the white-lists.
*/
//=== Check against blacklists, must not be rejected by any.
for (CheckedPattern cp : BLACKLISTS) {
CheckedPattern.Result result = cp.check(sql);
if (result.matcher != null) {
return String.format("%s, in statement: %s", result.explanation, sql);
}
}
//=== Check against whitelists, must be accepted by at least one.
boolean hadWLMatch = false;
for (CheckedPattern cp : WHITELISTS) {
if (cp.matches(sql)) {
hadWLMatch = true;
break;
}
}
if (!hadWLMatch) {
return String.format("AdHoc DDL contains an unsupported statement: %s", sql);
}
// The statement is permitted.
return null;
} | java |
static private boolean matchesStringAtIndex(char[] buf, int index, String str) {
int strLength = str.length();
if (index + strLength > buf.length) {
return false;
}
for (int i = 0; i < strLength; ++i) {
if (buf[index + i] != str.charAt(i)) {
return false;
}
}
return true;
} | java |
private static String removeCStyleComments(String ddl)
{
// Avoid Apache commons StringUtils.join() to minimize client dependencies.
StringBuilder sb = new StringBuilder();
for (String part : PAT_STRIP_CSTYLE_COMMENTS.split(ddl)) {
sb.append(part);
}
return sb.toString();
} | java |
private static ObjectToken findObjectToken(String objectTypeName)
{
if (objectTypeName != null) {
for (ObjectToken ot : OBJECT_TOKENS) {
if (ot.token.equalsIgnoreCase(objectTypeName)) {
return ot;
}
}
}
return null;
} | java |
synchronized void pushPair(Session session, Object[] row1, Object[] row2) {
if (maxRowsQueued == 0) {
trigger.fire(triggerType, name.name, table.getName().name, row1,
row2);
return;
}
if (rowsQueued >= maxRowsQueued) {
if (nowait) {
pendingQueue.removeLast(); // overwrite last
} else {
try {
wait();
} catch (InterruptedException e) {
/* ignore and resume */
}
rowsQueued++;
}
} else {
rowsQueued++;
}
pendingQueue.add(new TriggerData(session, row1, row2));
notify(); // notify pop's wait
} | java |
public synchronized CompiledPlan planSqlCore(String sql, StatementPartitioning partitioning) {
TrivialCostModel costModel = new TrivialCostModel();
DatabaseEstimates estimates = new DatabaseEstimates();
CompiledPlan plan = null;
// This try-with-resources block acquires a global lock on all planning
// This is required until we figure out how to do parallel planning.
try (QueryPlanner planner = new QueryPlanner(
sql, "PlannerTool", "PlannerToolProc", m_database,
partitioning, m_hsql, estimates, !VoltCompiler.DEBUG_MODE,
costModel, null, null, DeterminismMode.FASTER, false)) {
// do the expensive full planning.
planner.parse();
plan = planner.plan();
assert(plan != null);
}
catch (Exception e) {
/*
* Don't log PlanningErrorExceptions or HSQLParseExceptions, as they
* are at least somewhat expected.
*/
String loggedMsg = "";
if (!(e instanceof PlanningErrorException || e instanceof HSQLParseException)) {
logException(e, "Error compiling query");
loggedMsg = " (Stack trace has been written to the log.)";
}
if (e.getMessage() != null) {
throw new RuntimeException("SQL error while compiling query: " + e.getMessage() + loggedMsg, e);
}
throw new RuntimeException("SQL error while compiling query: " + e.toString() + loggedMsg, e);
}
if (plan == null) {
throw new RuntimeException("Null plan received in PlannerTool.planSql");
}
return plan;
} | java |
private boolean isReadOnlyProcedure(String pname) {
final Boolean b = m_procedureInfo.get().get(pname);
if (b == null) {
return false;
}
return b;
} | java |
private VoltTable[] aggregateProcedureProfileStats(VoltTable[] baseStats)
{
if (baseStats == null || baseStats.length != 1) {
return baseStats;
}
StatsProcProfTable timeTable = new StatsProcProfTable();
baseStats[0].resetRowPosition();
while (baseStats[0].advanceRow()) {
// Skip non-transactional procedures for some of these rollups until
// we figure out how to make them less confusing.
// NB: They still show up in the raw PROCEDURE stata.
boolean transactional = baseStats[0].getLong("TRANSACTIONAL") == 1;
if (!transactional) {
continue;
}
if ( ! baseStats[0].getString("STATEMENT").equalsIgnoreCase("<ALL>")) {
continue;
}
String pname = baseStats[0].getString("PROCEDURE");
timeTable.updateTable(!isReadOnlyProcedure(pname),
baseStats[0].getLong("TIMESTAMP"),
pname,
baseStats[0].getLong("PARTITION_ID"),
baseStats[0].getLong("INVOCATIONS"),
baseStats[0].getLong("MIN_EXECUTION_TIME"),
baseStats[0].getLong("MAX_EXECUTION_TIME"),
baseStats[0].getLong("AVG_EXECUTION_TIME"),
baseStats[0].getLong("FAILURES"),
baseStats[0].getLong("ABORTS"));
}
return new VoltTable[] { timeTable.sortByAverage("EXECUTION_TIME") };
} | java |
private VoltTable[] aggregateProcedureInputStats(VoltTable[] baseStats)
{
if (baseStats == null || baseStats.length != 1) {
return baseStats;
}
StatsProcInputTable timeTable = new StatsProcInputTable();
baseStats[0].resetRowPosition();
while (baseStats[0].advanceRow()) {
// Skip non-transactional procedures for some of these rollups until
// we figure out how to make them less confusing.
// NB: They still show up in the raw PROCEDURE stata.
boolean transactional = baseStats[0].getLong("TRANSACTIONAL") == 1;
if (!transactional) {
continue;
}
if ( ! baseStats[0].getString("STATEMENT").equalsIgnoreCase("<ALL>")) {
continue;
}
String pname = baseStats[0].getString("PROCEDURE");
timeTable.updateTable(!isReadOnlyProcedure(pname),
pname,
baseStats[0].getLong("PARTITION_ID"),
baseStats[0].getLong("TIMESTAMP"),
baseStats[0].getLong("INVOCATIONS"),
baseStats[0].getLong("MIN_PARAMETER_SET_SIZE"),
baseStats[0].getLong("MAX_PARAMETER_SET_SIZE"),
baseStats[0].getLong("AVG_PARAMETER_SET_SIZE")
);
}
return new VoltTable[] { timeTable.sortByInput("PROCEDURE_INPUT") };
} | java |
private VoltTable[] aggregateProcedureOutputStats(VoltTable[] baseStats)
{
if (baseStats == null || baseStats.length != 1) {
return baseStats;
}
StatsProcOutputTable timeTable = new StatsProcOutputTable();
baseStats[0].resetRowPosition();
while (baseStats[0].advanceRow()) {
// Skip non-transactional procedures for some of these rollups until
// we figure out how to make them less confusing.
// NB: They still show up in the raw PROCEDURE stata.
boolean transactional = baseStats[0].getLong("TRANSACTIONAL") == 1;
if (!transactional) {
continue;
}
if ( ! baseStats[0].getString("STATEMENT").equalsIgnoreCase("<ALL>")) {
continue;
}
String pname = baseStats[0].getString("PROCEDURE");
timeTable.updateTable(!isReadOnlyProcedure(pname),
pname,
baseStats[0].getLong("PARTITION_ID"),
baseStats[0].getLong("TIMESTAMP"),
baseStats[0].getLong("INVOCATIONS"),
baseStats[0].getLong("MIN_RESULT_SIZE"),
baseStats[0].getLong("MAX_RESULT_SIZE"),
baseStats[0].getLong("AVG_RESULT_SIZE")
);
}
return new VoltTable[] { timeTable.sortByOutput("PROCEDURE_OUTPUT") };
} | java |
public void notifyOfCatalogUpdate() {
m_procedureInfo = getProcedureInformationfoSupplier();
m_registeredStatsSources.put(StatsSelector.PROCEDURE,
new NonBlockingHashMap<Long, NonBlockingHashSet<StatsSource>>());
} | java |
public void addState(long agreementHSId) {
SiteState ss = m_stateBySite.get(agreementHSId);
if (ss != null) return;
ss = new SiteState();
ss.hsId = agreementHSId;
ss.newestConfirmedTxnId = m_newestConfirmedTxnId;
m_stateBySite.put(agreementHSId, ss);
} | java |
public Pair<CompleteTransactionTask, Boolean> pollFirstCompletionTask(CompletionCounter nextTaskCounter) {
// remove from the head
Pair<CompleteTransactionTask, Boolean> pair = m_compTasks.pollFirstEntry().getValue();
if (m_compTasks.isEmpty()) {
return pair;
}
// check next task for completion to ensure that the heads on all the site
// have the same transaction and timestamp
Pair<CompleteTransactionTask, Boolean> next = peekFirst();
if (nextTaskCounter.txnId == 0L) {
nextTaskCounter.txnId = next.getFirst().getMsgTxnId();
nextTaskCounter.completionCount++;
nextTaskCounter.timestamp = next.getFirst().getTimestamp();
} else if (nextTaskCounter.txnId == next.getFirst().getMsgTxnId() &&
nextTaskCounter.timestamp == next.getFirst().getTimestamp()) {
nextTaskCounter.completionCount++;
}
return pair;
} | java |
private static boolean isComparable(CompleteTransactionTask c1, CompleteTransactionTask c2) {
return c1.getMsgTxnId() == c2.getMsgTxnId() &&
MpRestartSequenceGenerator.isForRestart(c1.getTimestamp()) ==
MpRestartSequenceGenerator.isForRestart(c2.getTimestamp());
} | java |
public boolean matchCompleteTransactionTask(long txnId, long timestamp) {
if (!m_compTasks.isEmpty()) {
long lowestTxnId = m_compTasks.firstKey();
if (txnId == lowestTxnId) {
Pair<CompleteTransactionTask, Boolean> pair = m_compTasks.get(lowestTxnId);
return timestamp == pair.getFirst().getTimestamp();
}
}
return false;
} | java |
public static VoltTable aggregateStats(VoltTable stats) throws IllegalArgumentException
{
stats.resetRowPosition();
if (stats.getRowCount() == 0) {
return stats;
}
String role = null;
Map<Byte, State> states = new TreeMap<>();
while (stats.advanceRow()) {
final byte clusterId = (byte) stats.getLong(CN_REMOTE_CLUSTER_ID);
final String curRole = stats.getString(CN_ROLE);
if (role == null) {
role = curRole;
} else if (!role.equals(curRole)) {
throw new IllegalArgumentException("Inconsistent DR role across cluster nodes: " + stats.toFormattedString(false));
}
final State state = State.valueOf(stats.getString(CN_STATE));
states.put(clusterId, state.and(states.get(clusterId)));
}
// Remove the -1 placeholder if there are real cluster states
if (states.size() > 1) {
states.remove((byte) -1);
}
assert role != null;
stats.clearRowData();
for (Map.Entry<Byte, State> e : states.entrySet()) {
stats.addRow(role, e.getValue().name(), e.getKey());
}
return stats;
} | java |
public static String getString(String key)
{
if (RESOURCE_BUNDLE == null)
throw new RuntimeException("Localized messages from resource bundle '" + BUNDLE_NAME + "' not loaded during initialization of driver.");
try
{
if (key == null)
throw new IllegalArgumentException("Message key can not be null");
String message = RESOURCE_BUNDLE.getString(key);
if (message == null)
message = "Missing error message for key '" + key + "'";
return message;
}
catch (MissingResourceException e)
{
return '!' + key + '!';
}
} | java |
public void createAllDevNullTargets(Exception lastWriteException)
{
Map<Integer, SnapshotDataTarget> targets = Maps.newHashMap();
final AtomicInteger numTargets = new AtomicInteger();
for (Deque<SnapshotTableTask> tasksForSite : m_taskListsForHSIds.values()) {
for (SnapshotTableTask task : tasksForSite) {
// Close any created targets and replace them with DevNull, go web-scale
if (task.getTarget(true) != null) {
try {
task.getTarget().close();
} catch (Exception e) {
SNAP_LOG.error("Failed closing data target after error", e);
}
}
SnapshotDataTarget target = targets.get(task.m_table.getRelativeIndex());
if (target == null) {
target = new DevNullSnapshotTarget(lastWriteException);
final Runnable onClose = new TargetStatsClosure(target,
task.m_table.getTypeName(),
numTargets,
m_snapshotRecord);
target.setOnCloseHandler(onClose);
targets.put(task.m_table.getRelativeIndex(), target);
m_targets.add(target);
numTargets.incrementAndGet();
}
task.setTarget(target);
}
}
} | java |
private Map<String, Boolean> collapseSets(List<List<String>> allTableSets) {
Map<String, Boolean> answer = new TreeMap<>();
for (List<String> tables : allTableSets) {
for (String table : tables) {
answer.put(table, false);
}
}
return answer;
} | java |
private List<List<String>> decodeTables(String[] tablesThatMustBeEmpty) {
List<List<String>> answer = new ArrayList<>();
for (String tableSet : tablesThatMustBeEmpty) {
String tableNames[] = tableSet.split("\\+");
answer.add(Arrays.asList(tableNames));
}
return answer;
} | java |
public VoltTable[] run(SystemProcedureExecutionContext ctx) {
createAndExecuteSysProcPlan(SysProcFragmentId.PF_shutdownSync, SysProcFragmentId.PF_shutdownSyncDone);
SynthesizedPlanFragment pfs[] = new SynthesizedPlanFragment[] {
new SynthesizedPlanFragment(SysProcFragmentId.PF_shutdownCommand, true) };
executeSysProcPlanFragments(pfs, SysProcFragmentId.PF_procedureDone);
return new VoltTable[0];
} | java |
public void drain() throws InterruptedException, IOException {
ClientImpl currentClient = this.getClient();
if (currentClient == null) {
throw new IOException("Client is unavailable for drain().");
}
currentClient.drain();
} | java |
public void backpressureBarrier() throws InterruptedException, IOException {
ClientImpl currentClient = this.getClient();
if (currentClient == null) {
throw new IOException("Client is unavailable for backpressureBarrier().");
}
currentClient.backpressureBarrier();
} | java |
public boolean absolute(int position) {
if (position < 0) {
position += size;
}
if (position < 0) {
beforeFirst();
return false;
}
if (position > size) {
afterLast();
return false;
}
if (size == 0) {
return false;
}
if (position < currentPos) {
beforeFirst();
}
// go to the tagget row;
while (position > currentPos) {
next();
}
return true;
} | java |
private void printErrorAndQuit(String message)
{
System.out.println(message + "\n-------------------------------------------------------------------------------------\n");
printUsage();
System.exit(-1);
} | java |
public AppHelper printActualUsage()
{
System.out.println("-------------------------------------------------------------------------------------");
int maxLength = 24;
for(Argument a : Arguments)
if (maxLength < a.Name.length())
maxLength = a.Name.length();
for(Argument a : Arguments)
{
String template = "%1$" + String.valueOf(maxLength-1) + "s : ";
System.out.printf(template, a.Name);
System.out.println(a.Value);
}
System.out.println("-------------------------------------------------------------------------------------");
return this;
} | java |
public byte byteValue(String name)
{
try
{
return Byte.valueOf(this.getArgumentByName(name).Value);
}
catch(NullPointerException npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
catch(Exception x)
{
printErrorAndQuit(String.format("Argument '%s' could not be cast to type: 'byte'.", name));
}
return -1; // We will never get here: printErrorAndQuit will have terminated the application!
} | java |
public short shortValue(String name)
{
try
{
return Short.valueOf(this.getArgumentByName(name).Value);
}
catch(NullPointerException npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
catch(Exception x)
{
printErrorAndQuit(String.format("Argument '%s' could not be cast to type: 'short'.", name));
}
return -1; // We will never get here: printErrorAndQuit will have terminated the application!
} | java |
public int intValue(String name)
{
try
{
return Integer.valueOf(this.getArgumentByName(name).Value);
}
catch(NullPointerException npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
catch(Exception x)
{
printErrorAndQuit(String.format("Argument '%s' could not be cast to type: 'int'.", name));
}
return -1; // We will never get here: printErrorAndQuit will have terminated the application!
} | java |
public long longValue(String name)
{
try
{
return Long.valueOf(this.getArgumentByName(name).Value);
}
catch(NullPointerException npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
catch(Exception x)
{
printErrorAndQuit(String.format("Argument '%s' could not be cast to type: 'long'.", name));
}
return -1; // We will never get here: printErrorAndQuit will have terminated the application!
} | java |
public double doubleValue(String name)
{
try
{
return Double.valueOf(this.getArgumentByName(name).Value);
}
catch(NullPointerException npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
catch(Exception x)
{
printErrorAndQuit(String.format("Argument '%s' could not be cast to type: 'double'.", name));
}
return -1; // We will never get here: printErrorAndQuit will have terminated the application!
} | java |
public String stringValue(String name)
{
try
{
return this.getArgumentByName(name).Value;
}
catch(Exception npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
return null; // We will never get here: printErrorAndQuit will have terminated the application!
} | java |
public boolean booleanValue(String name)
{
try
{
return Boolean.valueOf(this.getArgumentByName(name).Value);
}
catch(NullPointerException npe)
{
printErrorAndQuit(String.format("Argument '%s' was not provided.", name));
}
catch(Exception x)
{
printErrorAndQuit(String.format("Argument '%s' could not be cast to type: 'boolean'.", name));
}
return false; // We will never get here: printErrorAndQuit will have terminated the application!
} | java |
public void setBounds(int x, int y, int w, int h) {
super.setBounds(x, y, w, h);
iSbHeight = sbHoriz.getPreferredSize().height;
iSbWidth = sbVert.getPreferredSize().width;
iHeight = h - iSbHeight;
iWidth = w - iSbWidth;
sbHoriz.setBounds(0, iHeight, iWidth, iSbHeight);
sbVert.setBounds(iWidth, 0, iSbWidth, iHeight);
adjustScroll();
iImage = null;
repaint();
} | java |
private String write(String logDir) throws IOException, ExecutionException, InterruptedException {
final File file = new File(logDir, "trace_" + System.currentTimeMillis() + ".json.gz");
if (file.exists()) {
throw new IOException("Trace file " + file.getAbsolutePath() + " already exists");
}
if (!file.getParentFile().canWrite() || !file.getParentFile().canExecute()) {
throw new IOException("Trace file " + file.getAbsolutePath() + " is not writable");
}
SettableFuture<Future<?>> f = SettableFuture.create();
m_work.offer(() -> f.set(dumpEvents(file)));
final Future<?> writeFuture = f.get();
if (writeFuture != null) {
writeFuture.get(); // Wait for the write to finish without blocking new events
return file.getAbsolutePath();
} else {
// A write is already in progress, ignore this request
return null;
}
} | java |
public static TraceEventBatch log(Category cat) {
final VoltTrace tracer = s_tracer;
if (tracer != null && tracer.isCategoryEnabled(cat)) {
final TraceEventBatch batch = new TraceEventBatch(cat);
tracer.queueEvent(batch);
return batch;
} else {
return null;
}
} | java |
public static String closeAllAndShutdown(String logDir, long timeOutMillis) throws IOException {
String path = null;
final VoltTrace tracer = s_tracer;
if (tracer != null) {
if (logDir != null) {
path = dump(logDir);
}
s_tracer = null;
if (timeOutMillis >= 0) {
try {
tracer.m_writerThread.shutdownNow();
tracer.m_writerThread.awaitTermination(timeOutMillis, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
}
}
tracer.shutdown();
}
return path;
} | java |
private static synchronized void start() throws IOException {
if (s_tracer == null) {
final VoltTrace tracer = new VoltTrace();
final Thread thread = new Thread(tracer);
thread.setDaemon(true);
thread.start();
s_tracer = tracer;
}
} | java |
public static String dump(String logDir) throws IOException {
String path = null;
final VoltTrace tracer = s_tracer;
if (tracer != null) {
final File dir = new File(logDir);
if (!dir.getParentFile().canWrite() || !dir.getParentFile().canExecute()) {
throw new IOException("Trace log parent directory " + dir.getParentFile().getAbsolutePath() +
" is not writable");
}
if (!dir.exists()) {
if (!dir.mkdir()) {
throw new IOException("Failed to create trace log directory " + dir.getAbsolutePath());
}
}
try {
path = tracer.write(logDir);
} catch (Exception e) {
s_logger.info("Unable to write trace file: " + e.getMessage(), e);
}
}
return path;
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.