ENG-4909 Bug: currently disable NESTLOOPINDEX plan for IN
333279
private static boolean disableNestedLoopIndexJoinForInComparison (AbstractPlanNode root, AbstractParsedStmt parsedStmt) {
        if (root.getPlanNodeType() == PlanNodeType.NESTLOOPINDEX) {
            assert(parsedStmt != null);
            return true;
        }

        return false;
    }
875186
@Override
	public org.structr.core.app.Query<T> disableSorting() {
		this.doNotSort = true;
		return this;
	}
1300788
@Override
	public void initAllBundles() {

		stopProcessIfNeeded();

		if (config.getUseBundleMapping()) {
			bundleMapping = resourceBundleHandler.getJawrBundleMapping();
		}

		boolean mappingFileExists = resourceBundleHandler.isExistingMappingFile();
		boolean processBundleFlag = !config.getUseBundleMapping() || !mappingFileExists;

		StopWatch stopWatch = ThreadLocalJawrContext.getStopWatch();

		List<JoinableResourceBundle> bundleToProcess = this.bundles;
		boolean forceStoreJawrBundleMapping = false;
		if (!processBundleFlag) {
			String storeJawrConfigHashcode = resourceBundleHandler.getJawrBundleMapping()
					.getProperty(JawrConstant.JAWR_CONFIG_HASHCODE);
			String jawrConfigHashcode = getJawrConfigHashcode();
			boolean rebuildAllBundles = !config.getUseSmartBundling()
					|| (!jawrConfigHashcode.equals(storeJawrConfigHashcode));
			if (!rebuildAllBundles) {
				bundleToProcess = getBundlesToRebuild();
				if (!bundleToProcess.isEmpty() && LOGGER.isDebugEnabled()) {

					StringBuilder msg = new StringBuilder(
							"Jawr has detect changes on the following bundles, which will be updated :\n");
					for (JoinableResourceBundle b : bundleToProcess) {
						msg.append(b.getName()).append("\n");
					}
					LOGGER.debug(msg.toString());
				}
			} else {
				bundleMapping.clear();
				if (LOGGER.isDebugEnabled() && !jawrConfigHashcode.equals(storeJawrConfigHashcode)) {
					LOGGER.debug("Jawr config has changed since last bundling process. All bundles will be processed.");
				}
			}

			forceStoreJawrBundleMapping = !bundleToProcess.isEmpty();
		}

		// Execute processing
		build(bundleToProcess, forceStoreJawrBundleMapping, stopWatch);
	}
1253355
private void deleteFromIndices(ApiType oldObj, String key) {
    for (Map.Entry<String, Function<ApiType, List<String>>> indexEntry : this.indexers.entrySet()) {
      Function<ApiType, List<String>> indexFunc = indexEntry.getValue();
      List<String> indexValues = indexFunc.apply(oldObj);
      if (io.kubernetes.client.util.common.Collections.isEmptyCollection(indexValues)) {
        continue;
      }

      Map<String, Set<String>> index = this.indices.get(indexEntry.getKey());
      if (index == null) {
        continue;
      }
      for (String indexValue : indexValues) {
        Set<String> indexSet = index.get(indexValue);
        if (indexSet != null) {
          indexSet.remove(key);
        }
      }
    }
  }
733161
function _closePane(index) {
            if (index === 0) {
                _closePanes();

                return;
            }

            if (angular.isUndefined(toggledPanes[index])) {
                return;
            }

            _closePane(index + 1);

            if (lxSelect.choicesViewSize === 'large') {
                lxSelect.panes.splice(toggledPanes[index].position, 1);
            } else {
                lxSelect.openedPanes.splice(toggledPanes[index].position, 1);
            }

            delete toggledPanes[index];
        }
161014
public void removeTangoQualityChangeListener(ITangoQualityChangeListener listener) 
                throws DevFailed
    {
        event_listeners.remove(ITangoQualityChangeListener.class,listener);
        if ( event_listeners.size() == 0 )
           unsubscribe_event(event_identifier);
    }
1056075
def disable_actions(options = {})
      options = Aws::Util.deep_merge(options, alarm_names: [@name])
      resp = @client.disable_alarm_actions(options)
      resp.data
    end
1263971
function CannotBuildDependencyGraphError(nestedError){
  this.name = 'CannotBuildDependencyGraphError';
  this.message = nestedError.message;
  this.stack = nestedError.stack;

  this.nestedError = nestedError;
}
665023
private void unprotectedUpdateCount(INode[] inodes, int numOfINodes,
                                      long nsDelta, long dsDelta) {
    for(int i=0; i < numOfINodes; i++) {
      if (inodes[i].isQuotaSet()) { // a directory with quota
        INodeDirectoryWithQuota node =(INodeDirectoryWithQuota)inodes[i];
        node.updateNumItemsInTree(nsDelta, dsDelta);
      }
    }
  }
379077
void removeGlobalUniqueIndex(GlobalUniqueIndex index, boolean preserveData) {
        getTopology().lock();
        String fn = index.getName();
        if (!uncommittedRemovedGlobalUniqueIndexes.contains(fn)) {
            uncommittedRemovedGlobalUniqueIndexes.add(fn);
            TopologyManager.removeGlobalUniqueIndex(sqlgGraph, fn);
            if (!preserveData) {
                getVertexLabel(index.getName()).ifPresent(
                        (VertexLabel vl) -> vl.remove(false));
            }
            getTopology().fire(index, "", TopologyChangeAction.DELETE);
        }
    }
460139
function isPaneToggled(parentIndex, indexOrKey) {
            var pane = lxSelect.choicesViewSize === 'large' ? lxSelect.panes[parentIndex] : lxSelect.openedPanes[parentIndex];

            if (angular.isUndefined(pane)) {
                return false;
            }

            var key = indexOrKey;
            if (angular.isObject(pane) && angular.isNumber(indexOrKey)) {
                key = (Object.keys(pane) || [])[indexOrKey];
            }

            return angular.isDefined(toggledPanes[parentIndex]) && toggledPanes[parentIndex].key === key;
        }
657887
function() {
    if(!this.isBase) {
      var self = this;
      var idx = this._searchLayerIndex();
      if(idx >= 0) {
        this.gmapsMap.overlayMapTypes.removeAt(idx);
      } else if (this.gmapsLayer.setMap){
        this.gmapsLayer.setMap(null);
      }
      this.model.unbind(null, null, this);
      this.unbind();
    }
  }
81259
function disableEachHooks(context) {
  context._disabledBeforeEach = context._beforeEach;
  context._disabledAfterEach = context._afterEach;
  context._beforeEach = [];
  context._afterEach = [];

  if (!context.parent) return;
  disableEachHooks(context.parent);
}
415048
function disallowBuiltIns(node) {
            if (node.callee.type !== "MemberExpression" || node.callee.computed) {
                return;
            }
            const propName = node.callee.property.name;

            if (DISALLOWED_PROPS.indexOf(propName) > -1) {
                context.report({
                    message: "Do not access Object.prototype method '{{prop}}' from target object.",
                    loc: node.callee.property.loc.start,
                    data: { prop: propName },
                    node
                });
            }
        }
1323905
private void internalRemoveApplessSubtrees(boolean isRoot) {

        if (isRoot) {
            computeAppCount();
        }
        Iterator<CmsAppCategoryNode> iter = m_children.iterator();
        while (iter.hasNext()) {
            CmsAppCategoryNode child = iter.next();
            if (child.m_appCount == 0) {
                iter.remove();
            } else {
                child.internalRemoveApplessSubtrees(false);
            }
        }
    }
651304
void cancelBuildsOnUpdate(Runnable closure) {
        GhprbCancelBuildsOnUpdateContext context = new GhprbCancelBuildsOnUpdateContext();
        ContextExtensionPoint.executeInContext(closure, context);

        extensions.add(new GhprbCancelBuildsOnUpdate(context.getOverrideGlobal()));
    }
391295
void cancelTasklet(final boolean mayInterruptIfRunning, final int taskletId) {
    lock.lock();
    try {
      // This is not ideal since we are using a linear time search on all the workers.
      final String workerId = getWhereTaskletWasScheduledTo(taskletId);
      if (workerId == null) {
        // launchTasklet called but not yet running.
        taskletsToCancel.add(taskletId);
        return;
      }

      if (mayInterruptIfRunning) {
        LOG.log(Level.FINE, "Cancelling running Tasklet with ID {0}.", taskletId);
        runningWorkers.get(workerId).cancelTasklet(taskletId);
      }
    } finally {
      lock.unlock();
    }
  }