Package org.teiid.query.sql.lang

Examples of org.teiid.query.sql.lang.OrderBy


    }

    private static PlanNode createSortNode(List<SingleElementSymbol> orderSymbols,
                                           Collection outputElements) {
        PlanNode sortNode = NodeFactory.getNewNode(NodeConstants.Types.SORT);
        sortNode.setProperty(NodeConstants.Info.SORT_ORDER, new OrderBy(orderSymbols));
        sortNode.setProperty(NodeConstants.Info.OUTPUT_COLS, new ArrayList(outputElements));
        return sortNode;
    }
View Full Code Here


        SymbolMap symbolMap = (SymbolMap)frame.getProperty(NodeConstants.Info.SYMBOL_MAP);
       
        PlanNode sortNode = NodeEditor.findParent(parentProject, NodeConstants.Types.SORT, NodeConstants.Types.SOURCE);
       
        if (sortNode != null && sortNode.hasBooleanProperty(NodeConstants.Info.UNRELATED_SORT)) {
          OrderBy sortOrder = (OrderBy)sortNode.getProperty(NodeConstants.Info.SORT_ORDER);
          boolean unrelated = false;
          for (OrderByItem item : sortOrder.getOrderByItems()) {
            if (!item.isUnrelated()) {
              continue;
            }
            Collection<ElementSymbol> elements = ElementCollectorVisitor.getElements(item.getSymbol(), true);
            for (ElementSymbol elementSymbol : elements) {
View Full Code Here

  private static void correctOrderBy(PlanNode frame,
      List<SingleElementSymbol> selectSymbols, PlanNode startNode) {
    PlanNode sort = NodeEditor.findParent(startNode, NodeConstants.Types.SORT, NodeConstants.Types.SOURCE | NodeConstants.Types.SET_OP);
    if (sort != null) { //special handling is needed since we are retaining the child aliases
      List<SingleElementSymbol> childProject = (List<SingleElementSymbol>)NodeEditor.findNodePreOrder(frame, NodeConstants.Types.PROJECT).getProperty(NodeConstants.Info.PROJECT_COLS);
      OrderBy elements = (OrderBy)sort.getProperty(NodeConstants.Info.SORT_ORDER);
      for (OrderByItem item : elements.getOrderByItems()) {
        item.setSymbol(childProject.get(selectSymbols.indexOf(item.getSymbol())));
      }
        sort.getGroups().clear();
        sort.addGroups(GroupsUsedByElementsVisitor.getGroups(elements));
    }
View Full Code Here

        joinCrits.addAll(combinedCrits);
        query.setCriteria(null);
    }
   
  private void processOrderBy(PlanNode node, QueryCommand query) {
    OrderBy orderBy = (OrderBy)node.getProperty(NodeConstants.Info.SORT_ORDER);
    query.setOrderBy(orderBy);
    if (query instanceof Query) {
      List<SingleElementSymbol> cols = query.getProjectedSymbols();
      for (OrderByItem item : orderBy.getOrderByItems()) {
        item.setExpressionPosition(cols.indexOf(item.getSymbol()));
      }
      QueryRewriter.rewriteOrderBy(query, orderBy, query.getProjectedSymbols(), new LinkedList<OrderByItem>());
    }
  }
View Full Code Here

            }
           
            convertAccessPatterns(symbolMap, node);
       
        } else if(type == NodeConstants.Types.SORT) {
          OrderBy orderBy = (OrderBy)node.getProperty(NodeConstants.Info.SORT_ORDER);
            ExpressionMappingVisitor.mapExpressions(orderBy, symbolMap);
            if (!singleMapping) {
                GroupsUsedByElementsVisitor.getGroups(orderBy, groups);
            }
        } else if(type == NodeConstants.Types.GROUP) { 
View Full Code Here

        dataNode.setReturnPeriod(3);
        dataNode.setElements(elements);
        dataNode.initialize(context, mgr, null);   
       
        SortNode sortNode = new SortNode(1);
      sortNode.setSortElements(new OrderBy(sortElements, sortTypes).getOrderByItems());
        sortNode.setMode(mode);
        sortNode.setElements(elements);
        sortNode.addChild(dataNode);       
        sortNode.initialize(context, mgr, null);   
       
View Full Code Here

        case NodeConstants.Types.TUPLE_LIMIT:
        case NodeConstants.Types.DUP_REMOVE:
        case NodeConstants.Types.SORT:
          if (root.hasBooleanProperty(NodeConstants.Info.UNRELATED_SORT)) {
            //add missing sort columns
            OrderBy elements = (OrderBy) root.getProperty(NodeConstants.Info.SORT_ORDER);
            outputElements = new ArrayList<SingleElementSymbol>(outputElements);
            boolean hasUnrelated = false;
            for (OrderByItem item : elements.getOrderByItems()) {
              if (item.getExpressionPosition() == -1) {
                int index = outputElements.indexOf(item.getSymbol());
                if (index != -1) {
                  item.setExpressionPosition(index);
                } else {
                  hasUnrelated = true;
                  outputElements.add(item.getSymbol());
                }
            }
          }
            if (!hasUnrelated) {
              root.setProperty(NodeConstants.Info.UNRELATED_SORT, false);
            }
          }
            assignOutputElements(root.getLastChild(), outputElements, metadata, capFinder, rules, analysisRecord, context);
            break;
        case NodeConstants.Types.SOURCE: {
            outputElements = (List<SingleElementSymbol>)determineSourceOutput(root, outputElements, metadata, capFinder);
              root.setProperty(NodeConstants.Info.OUTPUT_COLS, outputElements);
              List<SingleElementSymbol> childElements = filterVirtualElements(root, outputElements, metadata);
              assignOutputElements(root.getFirstChild(), childElements, metadata, capFinder, rules, analysisRecord, context);
            break;
        }
        case NodeConstants.Types.SET_OP: {
            for (PlanNode childNode : root.getChildren()) {
                PlanNode projectNode = NodeEditor.findNodePreOrder(childNode, NodeConstants.Types.PROJECT);
                  List<SingleElementSymbol> projectCols = (List<SingleElementSymbol>)projectNode.getProperty(NodeConstants.Info.PROJECT_COLS);
                  assignOutputElements(childNode, projectCols, metadata, capFinder, rules, analysisRecord, context);
              }
              break;
        }
        default: {
          if (root.getType() == NodeConstants.Types.PROJECT) {
            GroupSymbol intoGroup = (GroupSymbol)root.getProperty(NodeConstants.Info.INTO_GROUP);
                if (intoGroup != null) { //if this is a project into, treat the nodes under the source as a new plan root
                    PlanNode intoRoot = NodeEditor.findNodePreOrder(root, NodeConstants.Types.SOURCE);
                    execute(intoRoot.getFirstChild(), metadata, capFinder, rules, analysisRecord, context);
                    return;
                }
                List<SingleElementSymbol> projectCols = outputElements;
                boolean modifiedProject = false;
                PlanNode sortNode = NodeEditor.findParent(root, NodeConstants.Types.SORT, NodeConstants.Types.SOURCE);
                if (sortNode != null && sortNode.hasBooleanProperty(NodeConstants.Info.UNRELATED_SORT)) {
                  //if this is the initial rule run, remove unrelated order before changing the project cols
                  if (rules.contains(RuleConstants.ASSIGN_OUTPUT_ELEMENTS)) {
                    OrderBy elements = (OrderBy) sortNode.getProperty(NodeConstants.Info.SORT_ORDER);
                    projectCols = new ArrayList<SingleElementSymbol>(projectCols);
                    for (OrderByItem item : elements.getOrderByItems()) {
                      if (item.getExpressionPosition() == -1) {
                        projectCols.remove(item.getSymbol());
                      }
                    }
                  } else {
View Full Code Here

        PlanNode access = NodeEditor.findParent(sort, NodeConstants.Types.ACCESS);
        if (sort.hasBooleanProperty(NodeConstants.Info.UNRELATED_SORT) ||
            (access != null && capFinder != null && CapabilitiesUtil.supports(Capability.QUERY_ORDERBY_UNRELATED, RuleRaiseAccess.getModelIDFromAccess(access, metadata), metadata, capFinder))) {
        return outputElements;
        }
        OrderBy sortOrder = (OrderBy)sort.getProperty(NodeConstants.Info.SORT_ORDER);
        List<SingleElementSymbol> topCols = FrameUtil.findTopCols(sort);
       
        SymbolMap symbolMap = (SymbolMap)root.getProperty(NodeConstants.Info.SYMBOL_MAP);
       
        List<ElementSymbol> symbolOrder = symbolMap.getKeys();
       
        for (OrderByItem item : sortOrder.getOrderByItems()) {
            final Expression expr = item.getSymbol();
            int index = topCols.indexOf(expr);
            if (index < 0) {
              continue;
            }
View Full Code Here

          for (int i = 0; i < filteredIndex.length; i++) {
            newMap.addMapping(originalOrder.get(filteredIndex[i]), originalExpressionOrder.get(filteredIndex[i]));
      }
            PlanNode sortNode = NodeEditor.findNodePreOrder(sourceNode, NodeConstants.Types.SORT, NodeConstants.Types.PROJECT);
          if (sortNode != null) {
            OrderBy elements = (OrderBy) sortNode.getProperty(NodeConstants.Info.SORT_ORDER);
            for (OrderByItem item : elements.getOrderByItems()) {
              if (item.getExpressionPosition() == -1) {
                continue;
              }
              item.setExpressionPosition(-1);
              for (int i = 0; i < filteredIndex.length; i++) {
View Full Code Here

             
                      Expression aggExpr = agg.getExpression();
                      if(aggExpr != null) {
                          AggregateSymbolCollectorVisitor.getAggregates(aggExpr, requiredSymbols, requiredSymbols);
                      }
                      OrderBy orderBy = agg.getOrderBy();
                      if(orderBy != null) {
                          AggregateSymbolCollectorVisitor.getAggregates(orderBy, requiredSymbols, requiredSymbols);
                      }
          }
        }
View Full Code Here

TOP

Related Classes of org.teiid.query.sql.lang.OrderBy

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.