Changeset 53:17c697469b47


Ignore:
Timestamp:
03/14/12 15:27:35 (6 years ago)
Author:
Giorgos Garbis <ggarbis@…>
Branch:
default
Parents:
52:bd92581c8a5b (diff), 49:b2625b0d312b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

merge with mine

Files:
2 edited

Legend:

Unmodified
Added
Removed
  • evaluation/src/main/java/org/openrdf/query/algebra/evaluation/iterator/StSPARQLGroupIterator.java

    r47 r53  
    9595 
    9696        public StSPARQLGroupIterator(EvaluationStrategy strategy, Group group, BindingSet parentBindings) 
    97                         throws QueryEvaluationException 
    98                         { 
     97                throws QueryEvaluationException 
     98        { 
    9999                this.strategy = strategy; 
    100100                this.group = group; 
    101101                this.parentBindings = parentBindings; 
    102102                super.setIterator(createIterator()); 
    103                         } 
     103        } 
    104104 
    105105        /*---------* 
     
    108108 
    109109        private Iterator<BindingSet> createIterator() 
    110                         throws QueryEvaluationException 
    111                         { 
     110                throws QueryEvaluationException 
     111        { 
    112112                Collection<Entry> entries = buildEntries(); 
    113113                Collection<BindingSet> bindingSets = new LinkedList<BindingSet>(); 
     
    142142 
    143143                return bindingSets.iterator(); 
    144                         } 
     144        } 
    145145 
    146146        private Collection<Entry> buildEntries() 
    147                         throws QueryEvaluationException 
    148                         { 
     147                throws QueryEvaluationException 
     148        { 
    149149                CloseableIteration<BindingSet, QueryEvaluationException> iter; 
    150150                iter = strategy.evaluate(group.getArg(), parentBindings); 
     
    184184                } 
    185185 
    186                         } 
     186        } 
    187187 
    188188        /** 
     
    245245 
    246246                public Entry(BindingSet prototype) 
    247                                 throws ValueExprEvaluationException, QueryEvaluationException 
    248                                 { 
     247                        throws ValueExprEvaluationException, QueryEvaluationException 
     248                { 
    249249                        this.prototype = prototype; 
    250250                        this.aggregates = new LinkedHashMap<String, Aggregate>(); 
     
    287287                                } 
    288288                        } 
    289                                 } 
     289                } 
    290290 
    291291                public BindingSet getPrototype() { 
     
    294294 
    295295                public void addSolution(BindingSet bindingSet) 
    296                                 throws QueryEvaluationException 
    297                                 { 
     296                        throws QueryEvaluationException 
     297                { 
    298298                        for (Aggregate aggregate : aggregates.values()) { 
    299299                                aggregate.processAggregate(bindingSet); 
     
    303303                                //spatialAggregates.processAggregate(bindingSet); 
    304304                        } 
    305                                 } 
     305                } 
    306306 
    307307                public void bindSolution(QueryBindingSet sol) 
    308                                 throws QueryEvaluationException 
    309                                 { 
     308                        throws QueryEvaluationException 
     309                { 
    310310                        for (String name : aggregates.keySet()) { 
    311311                                try { 
     
    371371 
    372372 
    373                                 } 
     373                } 
    374374 
    375375                /** 
     
    667667 
    668668                private Aggregate create(AggregateOperator operator) 
    669                                 throws ValueExprEvaluationException, QueryEvaluationException 
    670                                 { 
     669                        throws ValueExprEvaluationException, QueryEvaluationException 
     670                { 
    671671                        if (operator instanceof Count) { 
    672672                                return new CountAggregate((Count)operator); 
     
    691691                        } 
    692692                        return null; 
    693                                 } 
     693                } 
    694694        } 
    695695 
     
    725725 
    726726                protected Value evaluate(BindingSet s) 
    727                                 throws QueryEvaluationException 
    728                                 { 
     727                        throws QueryEvaluationException 
     728                { 
    729729                        try { 
    730730                                return strategy.evaluate(getArg(), s); 
     
    733733                                return null; // treat missing or invalid expressions as null 
    734734                        } 
    735                                 } 
     735                } 
    736736        } 
    737737 
     
    746746                @Override 
    747747                public void processAggregate(BindingSet s) 
    748                                 throws QueryEvaluationException 
    749                                 { 
     748                        throws QueryEvaluationException 
     749                { 
    750750                        if (getArg() != null) { 
    751751                                Value value = evaluate(s); 
     
    757757                                count++; 
    758758                        } 
    759                                 } 
     759                } 
    760760 
    761761                @Override 
     
    777777                @Override 
    778778                public void processAggregate(BindingSet s) 
    779                                 throws QueryEvaluationException 
    780                                 { 
     779                        throws QueryEvaluationException 
     780                { 
    781781                        Value v = evaluate(s); 
    782782                        if (distinct(v)) { 
     
    788788                                } 
    789789                        } 
    790                                 } 
     790                } 
    791791 
    792792                @Override 
     
    808808                @Override 
    809809                public void processAggregate(BindingSet s) 
    810                                 throws QueryEvaluationException 
    811                                 { 
     810                        throws QueryEvaluationException 
     811                { 
    812812                        Value v = evaluate(s); 
    813813                        if (distinct(v)) { 
     
    819819                                } 
    820820                        } 
    821                                 } 
     821                } 
    822822 
    823823                @Override 
     
    839839                @Override 
    840840                public void processAggregate(BindingSet s) 
    841                                 throws QueryEvaluationException 
    842                                 { 
     841                        throws QueryEvaluationException 
     842                { 
    843843                        if (typeError != null) { 
    844844                                // halt further processing if a type error has been raised 
     
    863863                                } 
    864864                        } 
    865                                 } 
     865                } 
    866866 
    867867                @Override 
    868868                public Value getValue() 
    869                                 throws ValueExprEvaluationException 
    870                                 { 
     869                        throws ValueExprEvaluationException 
     870                { 
    871871                        if (typeError != null) { 
    872872                                throw typeError; 
     
    874874 
    875875                        return sum; 
    876                                 } 
     876                } 
    877877        } 
    878878 
     
    891891                @Override 
    892892                public void processAggregate(BindingSet s) 
    893                                 throws QueryEvaluationException 
    894                                 { 
     893                        throws QueryEvaluationException 
     894                { 
    895895                        if (typeError != null) { 
    896896                                // Prevent calculating the aggregate further if a type error has 
     
    920920                                } 
    921921                        } 
    922                                 } 
     922                } 
    923923 
    924924                @Override 
    925925                public Value getValue() 
    926                                 throws ValueExprEvaluationException 
    927                                 { 
     926                        throws ValueExprEvaluationException 
     927                { 
    928928                        if (typeError != null) { 
    929929                                // a type error occurred while processing the aggregate, throw it 
     
    938938                        Literal sizeLit = vf.createLiteral(count); 
    939939                        return MathUtil.compute(sum, sizeLit, MathOp.DIVIDE); 
    940                                 } 
     940                } 
    941941        } 
    942942 
     
    951951                @Override 
    952952                public void processAggregate(BindingSet s) 
    953                                 throws QueryEvaluationException 
    954                                 { 
     953                        throws QueryEvaluationException 
     954                { 
    955955                        if (sample == null) { 
    956956                                sample = evaluate(s); 
    957957                        } 
    958                                 } 
     958                } 
    959959 
    960960                @Override 
     
    972972                public ConcatAggregate(GroupConcat groupConcatOp) 
    973973                                throws ValueExprEvaluationException, QueryEvaluationException 
    974                                 { 
     974                { 
    975975                        super(groupConcatOp); 
    976976                        ValueExpr separatorExpr = groupConcatOp.getSeparator(); 
     
    979979                                separator = separatorValue.stringValue(); 
    980980                        } 
    981                                 } 
     981                } 
    982982 
    983983                @Override 
    984984                public void processAggregate(BindingSet s) 
    985                                 throws QueryEvaluationException 
    986                                 { 
     985                        throws QueryEvaluationException 
     986                { 
    987987                        Value v = evaluate(s); 
    988988                        if (v != null && distinct(v)) { 
     
    990990                                concatenated.append(separator); 
    991991                        } 
    992                                 } 
     992                } 
    993993 
    994994                @Override 
  • evaluation/src/main/java/org/openrdf/query/algebra/evaluation/iterator/StSPARQLGroupIterator.java

    r52 r53  
    347347                                ValueExpr expr = spatialAggregates.get(name); 
    348348 
    349                                 StrabonPolyhedron poly = null; 
    350349                                Value val = null; 
    351                                 //LiteralImpl lit  
    352350                                try { 
    353351                                        val = evaluateConstruct(expr, this.prototype); 
     
    356354                                } 
    357355                                if (val != null) { 
    358                                         Literal wkt = new LiteralImpl(val.toString(),new URIImpl(StrabonPolyhedron.ogcGeometry)); 
    359                                         sol.setBinding(name,wkt); 
     356                                        if(val instanceof StrabonPolyhedron) 
     357                                        { 
     358                                                String label = val.toString()+";http://www.opengis.net/def/crs/EPSG/0/"+((StrabonPolyhedron)val).getGeometry().getSRID(); 
     359                                                Literal wkt = new LiteralImpl(label,new URIImpl(StrabonPolyhedron.ogcGeometry)); 
     360                                                sol.setBinding(name,wkt); 
     361                                        } 
     362                                        else 
     363                                        { 
     364                                                sol.setBinding(name, val); 
     365                                        } 
    360366                                } 
    361367 
     
    402408                                                leftArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(0),prototype); 
    403409                                                rightArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(1),prototype); 
    404  
    405                                                 int leftSRID = leftArg.getGeometry().getSRID(); 
    406                                                 int rightSRID = rightArg.getGeometry().getSRID(); 
    407                                                 if(leftSRID != rightSRID) 
    408                                                 { 
    409                                                         //XXX Will have to express the second argument in the SRID of the first 
    410                                                         rightArg.setGeometry(StrabonPolyhedron.convertSRID(rightArg.getGeometry(),leftSRID, rightSRID)); 
    411                                                 } 
    412410                                                return StrabonPolyhedron.union(leftArg, rightArg); 
    413411                                        } 
     
    445443                                        leftArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(0),prototype); 
    446444                                        rightArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(1),prototype); 
    447                                         int leftSRID = leftArg.getGeometry().getSRID(); 
    448                                         int rightSRID = rightArg.getGeometry().getSRID(); 
    449                                         if(leftSRID != rightSRID) 
    450                                         { 
    451                                                 //XXX Will have to express the second argument in the SRID of the first 
    452                                                 rightArg.setGeometry(StrabonPolyhedron.convertSRID(rightArg.getGeometry(),leftSRID, rightSRID)); 
    453                                         } 
    454445                                        return StrabonPolyhedron.intersection(leftArg, rightArg); 
    455446                                } 
     
    458449                                        leftArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(0),prototype); 
    459450                                        rightArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(1),prototype); 
    460                                         int leftSRID = leftArg.getGeometry().getSRID(); 
    461                                         int rightSRID = rightArg.getGeometry().getSRID(); 
    462                                         if(leftSRID != rightSRID) 
    463                                         { 
    464                                                 //XXX Will have to express the second argument in the SRID of the first 
    465                                                 rightArg.setGeometry(StrabonPolyhedron.convertSRID(rightArg.getGeometry(),leftSRID, rightSRID)); 
    466                                         } 
    467451                                        return StrabonPolyhedron.difference(leftArg, rightArg); 
    468452                                } 
     
    471455                                        leftArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(0),prototype); 
    472456                                        rightArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(1),prototype); 
    473                                         int leftSRID = leftArg.getGeometry().getSRID(); 
    474                                         int rightSRID = rightArg.getGeometry().getSRID(); 
    475                                         if(leftSRID != rightSRID) 
    476                                         { 
    477                                                 //XXX Will have to express the second argument in the SRID of the first 
    478                                                 rightArg.setGeometry(StrabonPolyhedron.convertSRID(rightArg.getGeometry(),leftSRID, rightSRID)); 
    479                                         } 
    480457                                        return StrabonPolyhedron.symDifference(leftArg, rightArg); 
    481458                                } 
     
    490467                                        leftArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(0),prototype); 
    491468                                        rightArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(1),prototype); 
    492                                         int leftSRID = leftArg.getGeometry().getSRID(); 
    493                                         int rightSRID = rightArg.getGeometry().getSRID(); 
    494                                         if(leftSRID != rightSRID) 
    495                                         { 
    496                                                 //XXX Will have to express the second argument in the SRID of the first 
    497                                                 rightArg.setGeometry(StrabonPolyhedron.convertSRID(rightArg.getGeometry(),leftSRID, rightSRID)); 
    498                                         } 
    499469                                        return vf.createLiteral(""+StrabonPolyhedron.distance(leftArg, rightArg), XMLSchema.DOUBLE); 
    500470                                } 
Note: See TracChangeset for help on using the changeset viewer.