Changeset 43:07eaeca98f59


Ignore:
Timestamp:
03/10/12 03:55:10 (6 years ago)
Author:
Manos Karpathiotakis <mk@…>
Branch:
default
Message:

Fixed bug related with aggregate functions. Confidence calculation should now work

Files:
3 edited

Legend:

Unmodified
Added
Removed
  • generaldb/src/main/java/org/openrdf/sail/generaldb/evaluation/GeneralDBEvaluation.java

    r25 r43  
    145145        protected HashMap<Integer,String> geoNames = new HashMap<Integer,String>(); 
    146146 
     147        protected List<GeneralDBSqlExpr> thematicExpressions = new ArrayList<GeneralDBSqlExpr>(5); 
     148 
    147149        //used to retrieve the appropriate column in the Binding Iteration 
    148150        protected HashMap<GeneralDBSpatialFuncInfo, Integer> constructIndexesAndNames = new HashMap<GeneralDBSpatialFuncInfo, Integer>(); 
     
    167169        public CloseableIteration<BindingSet, QueryEvaluationException> evaluate(TupleExpr expr, 
    168170                        BindingSet bindings) 
    169         throws QueryEvaluationException 
    170         { 
     171                        throws QueryEvaluationException 
     172                        { 
    171173                if (expr instanceof GeneralDBSelectQuery) 
    172174                        return evaluate((GeneralDBSelectQuery)expr, bindings); 
     
    178180                } 
    179181                return super.evaluate(expr, bindings); 
    180         } 
     182                        } 
    181183        @Override 
    182184        public Value evaluate(ValueExpr expr, BindingSet bindings) 
    183                         throws ValueExprEvaluationException, QueryEvaluationException 
    184                         { 
     185        throws ValueExprEvaluationException, QueryEvaluationException 
     186        { 
    185187                if (expr instanceof Var) { 
    186188                        return evaluate((Var)expr, bindings); 
     
    190192                } 
    191193                return super.evaluate(expr, bindings); 
    192                         } 
     194        } 
    193195 
    194196        /** 
     
    199201        { 
    200202                boolean groupBy = false; 
    201 //              //Case met when ORDER BY involved (?) 
    202 //              if(var.getName().startsWith("-mbbVar-")) 
    203 //              { 
    204 //                      var.setName(var.getName().replace("-mbbVar-","")); 
    205 //              } 
    206                  
     203                //              //Case met when ORDER BY involved (?) 
     204                //              if(var.getName().startsWith("-mbbVar-")) 
     205                //              { 
     206                //                      var.setName(var.getName().replace("-mbbVar-","")); 
     207                //              } 
     208 
    207209                //Case met when evaluating a construct function inside an aggregate  
    208210                if(var.getName().endsWith("?spatial")) 
     
    257259                        } 
    258260                } 
    259                  
     261 
    260262                Function function = FunctionRegistry.getInstance().get(fc.getURI()); 
    261263 
    262 //              if(fc.getParentNode() instanceof Filter) 
    263 //              { 
    264 //                      //Traditional Behavior! 
    265 //                      try { 
    266 //                              if (function == null) { 
    267 //                                      throw new QueryEvaluationException("Unknown function '" + fc.getURI() + "'"); 
    268 //                              } 
    269 // 
    270 //                              List<ValueExpr> args = fc.getArgs(); 
    271 // 
    272 //                              Value[] argValues = new Value[args.size()]; 
    273 // 
    274 //                              for (int i = 0; i < args.size(); i++) { 
    275 // 
    276 //                                      argValues[i] = evaluate(args.get(i), bindings); 
    277 // 
    278 //                              } 
    279 // 
    280 //                              return function.evaluate(tripleSource.getValueFactory(), argValues);} catch (ValueExprEvaluationException e) { 
    281 //                                      e.printStackTrace(); 
    282 //                              } catch (QueryEvaluationException e) { 
    283 //                                      e.printStackTrace(); 
    284 //                              } 
    285 //              } 
     264                //              if(fc.getParentNode() instanceof Filter) 
     265                //              { 
     266                //                      //Traditional Behavior! 
     267                //                      try { 
     268                //                              if (function == null) { 
     269                //                                      throw new QueryEvaluationException("Unknown function '" + fc.getURI() + "'"); 
     270                //                              } 
     271                // 
     272                //                              List<ValueExpr> args = fc.getArgs(); 
     273                // 
     274                //                              Value[] argValues = new Value[args.size()]; 
     275                // 
     276                //                              for (int i = 0; i < args.size(); i++) { 
     277                // 
     278                //                                      argValues[i] = evaluate(args.get(i), bindings); 
     279                // 
     280                //                              } 
     281                // 
     282                //                              return function.evaluate(tripleSource.getValueFactory(), argValues);} catch (ValueExprEvaluationException e) { 
     283                //                                      e.printStackTrace(); 
     284                //                              } catch (QueryEvaluationException e) { 
     285                //                                      e.printStackTrace(); 
     286                //                              } 
     287                //              } 
    286288                ValueExpr left = fc.getArgs().get(0); 
    287289 
     
    299301 
    300302 
    301 //              if(!(function instanceof EnvelopeFunc)  
    302 //                              && !(function instanceof ConvexHullFunc)  
    303 //                              && !(function instanceof BoundaryFunc)) 
     303                //              if(!(function instanceof EnvelopeFunc)  
     304                //                              && !(function instanceof ConvexHullFunc)  
     305                //                              && !(function instanceof BoundaryFunc)) 
    304306                if ( fc.getArgs().size() == 2 ) 
    305307                { 
     
    313315                        } 
    314316                } 
    315                  
     317 
    316318                try { 
    317319                        if ( function instanceof SpatialConstructFunc )  
     
    336338                                        return null; 
    337339                                } 
    338                                  
     340 
    339341                                if(rightResult instanceof StrabonPolyhedron) 
    340342                                { 
     
    349351                                        return null; 
    350352                                } 
    351                                  
    352                                  
     353 
     354 
    353355                                if(function instanceof AboveFunc) 
    354356                                { 
     
    404406                                        funcResult = leftGeom.touches(rightGeom); 
    405407                                } 
    406                                  
     408 
    407409                                return funcResult ? BooleanLiteralImpl.TRUE : BooleanLiteralImpl.FALSE; 
    408410                        } 
     
    480482        @Override 
    481483        public CloseableIteration<BindingSet, QueryEvaluationException> evaluate(Group node, BindingSet bindings) 
    482                         throws QueryEvaluationException 
    483                         { 
    484 //              Set<String> tmp1 = node.getAggregateBindingNames(); 
    485 //              Set<String> tmp2 = node.getAssuredBindingNames(); 
    486 //              Set<String> tmp3 = node.getBindingNames(); 
    487 //              Set<String> tmp4 = node.getGroupBindingNames(); 
    488 //              for(String tmp : tmp4) 
    489 //              { 
    490 //                      //System.out.println(node.g); 
    491 //              } 
     484        throws QueryEvaluationException 
     485        { 
     486                //              Set<String> tmp1 = node.getAggregateBindingNames(); 
     487                //              Set<String> tmp2 = node.getAssuredBindingNames(); 
     488                //              Set<String> tmp3 = node.getBindingNames(); 
     489                //              Set<String> tmp4 = node.getGroupBindingNames(); 
     490                //              for(String tmp : tmp4) 
     491                //              { 
     492                //                      //System.out.println(node.g); 
     493                //              } 
    492494                return new StSPARQLGroupIterator(this, node, bindings); 
    493                         } 
     495        } 
    494496 
    495497        @Override 
    496498        public CloseableIteration<BindingSet, QueryEvaluationException> evaluate(Order node, BindingSet bindings) 
    497                         throws QueryEvaluationException 
    498                         { 
     499        throws QueryEvaluationException 
     500        { 
    499501                StSPARQLValueComparator vcmp = new StSPARQLValueComparator(); 
    500502                StSPARQLOrderComparator cmp = new StSPARQLOrderComparator(this, node, vcmp); 
     
    502504                long limit = getLimit(node); 
    503505                return new OrderIterator(evaluate(node.getArg(), bindings), cmp, limit, reduced); 
    504                         } 
     506        } 
    505507 
    506508        //Duplicated from EvaluationStrategyImpl 
     
    585587 
    586588        protected abstract CloseableIteration<BindingSet, QueryEvaluationException> evaluate(GeneralDBSelectQuery qb, BindingSet b) 
    587                         throws UnsupportedRdbmsOperatorException, RdbmsQueryEvaluationException; 
     589        throws UnsupportedRdbmsOperatorException, RdbmsQueryEvaluationException; 
    588590 
    589591        protected String toQueryString(GeneralDBSelectQuery qb, QueryBindingSet bindings, List<Object> parameters) 
    590                 throws RdbmsException, UnsupportedRdbmsOperatorException 
     592        throws RdbmsException, UnsupportedRdbmsOperatorException 
    591593        { 
    592594                GeneralDBQueryBuilder query = factory.createQueryBuilder(); 
     
    663665                        locateColumnVars(expr,qb.getVars()); 
    664666 
    665                         query.construct(expr);  
    666                         GeneralDBSpatialFuncInfo info = null; 
    667                         switch(constructReturnType(expr)) 
    668                         { 
    669                         case 1: 
    670                                 //Integer 
    671                                 info = new GeneralDBSpatialFuncInfo((String) pairs.getKey(), typeOfField.Integer); 
    672                                 break; 
    673                         case 2:  
    674                                 //String 
    675                                 info = new GeneralDBSpatialFuncInfo((String) pairs.getKey(), typeOfField.String); 
    676                                 break; 
    677                         case 3:  
    678                                 //Boolean 
    679                                 info = new GeneralDBSpatialFuncInfo((String) pairs.getKey(), typeOfField.Boolean); 
    680                                 break; 
    681                         case 4:  
    682                                 //WKB 
    683                                 info = new GeneralDBSpatialFuncInfo((String) pairs.getKey(), typeOfField.WKB); 
    684                                 break; 
    685                         case 5:  
    686                                 //DOUBLE 
    687                                 info = new GeneralDBSpatialFuncInfo((String) pairs.getKey(), typeOfField.Double); 
    688                                 break; 
    689                         default: throw new UnsupportedRdbmsOperatorException("No such spatial expression exists!"); 
    690                         } 
    691  
    692                         //constructIndexesAndNames.put((String) pairs.getKey(),index++); 
    693                         constructIndexesAndNames.put(info,index++); 
     667                        //Assuming thematic aggregates and spatial expressions won't be combined 
     668                        if(!this.thematicExpressions.contains(expr)) 
     669                        { 
     670                                query.construct(expr); 
     671 
     672 
     673                                GeneralDBSpatialFuncInfo info = null; 
     674                                switch(constructReturnType(expr)) 
     675                                { 
     676                                case 1: 
     677                                        //Integer 
     678                                        info = new GeneralDBSpatialFuncInfo((String) pairs.getKey(), typeOfField.Integer); 
     679                                        break; 
     680                                case 2:  
     681                                        //String 
     682                                        info = new GeneralDBSpatialFuncInfo((String) pairs.getKey(), typeOfField.String); 
     683                                        break; 
     684                                case 3:  
     685                                        //Boolean 
     686                                        info = new GeneralDBSpatialFuncInfo((String) pairs.getKey(), typeOfField.Boolean); 
     687                                        break; 
     688                                case 4:  
     689                                        //WKB 
     690                                        info = new GeneralDBSpatialFuncInfo((String) pairs.getKey(), typeOfField.WKB); 
     691                                        break; 
     692                                case 5:  
     693                                        //DOUBLE 
     694                                        info = new GeneralDBSpatialFuncInfo((String) pairs.getKey(), typeOfField.Double); 
     695                                        break; 
     696                                default: throw new UnsupportedRdbmsOperatorException("No such spatial expression exists!"); 
     697                                } 
     698 
     699                                //constructIndexesAndNames.put((String) pairs.getKey(),index++); 
     700                                constructIndexesAndNames.put(info,index++); 
     701                        } 
    694702                } 
    695703                // 
     
    786794                else if(expr instanceof GeneralDBNumericColumn)//ColumnVar at least 
    787795                { 
     796                        boolean found = false; 
    788797                        String name = ((GeneralDBNumericColumn) expr).getVarName(); 
    789798 
     
    798807                                        GeneralDBSqlExpr exprCopy = new GeneralDBLabelColumn(reference,false); 
    799808                                        expr.replaceWith(exprCopy); 
    800                                 } 
     809                                        found = true; 
     810                                } 
     811                        } 
     812 
     813                        if(!found) 
     814                        { 
     815                                //Will keep non-spatial math expressions to avoid iterating through them  
     816                                //at QueryBuilder.construct. Otherwise, exception occurs.  
     817                                //This case probably only concerns thematic aggregates 
     818                                this.thematicExpressions.add((GeneralDBSqlExpr)expr.getParentNode()); 
    801819                        } 
    802820                        //System.out.println("stopper"); 
  • generaldb/src/main/java/org/openrdf/sail/generaldb/optimizers/GeneralDBSelectQueryOptimizer.java

    r24 r43  
    3636import org.openrdf.query.algebra.And; 
    3737import org.openrdf.query.algebra.Avg; 
     38import org.openrdf.query.algebra.BinaryValueOperator; 
    3839import org.openrdf.query.algebra.Compare; 
    3940import org.openrdf.query.algebra.Distinct; 
     
    5556import org.openrdf.query.algebra.StatementPattern; 
    5657import org.openrdf.query.algebra.TupleExpr; 
     58import org.openrdf.query.algebra.UnaryValueOperator; 
    5759import org.openrdf.query.algebra.Union; 
    5860import org.openrdf.query.algebra.ValueExpr; 
     
    8890import org.openrdf.sail.generaldb.algebra.GeneralDBSqlEq; 
    8991import org.openrdf.sail.generaldb.algebra.GeneralDBSqlOr; 
     92import org.openrdf.sail.generaldb.algebra.GeneralDBSqlSpatialMetricBinary; 
     93import org.openrdf.sail.generaldb.algebra.GeneralDBSqlSpatialMetricUnary; 
    9094import org.openrdf.sail.generaldb.algebra.GeneralDBURIColumn; 
    9195import org.openrdf.sail.generaldb.algebra.GeneralDBUnionItem; 
     96import org.openrdf.sail.generaldb.algebra.base.BinaryGeneralDBOperator; 
    9297import org.openrdf.sail.generaldb.algebra.base.GeneralDBQueryModelVisitorBase; 
    9398import org.openrdf.sail.generaldb.algebra.base.GeneralDBSqlExpr; 
     99import org.openrdf.sail.generaldb.algebra.base.UnaryGeneralDBOperator; 
    94100import org.openrdf.sail.generaldb.algebra.factories.GeneralDBSqlExprFactory; 
    95101import org.openrdf.sail.rdbms.exceptions.RdbmsException; 
     
    977983 
    978984                        } 
     985                        //Issue: MathExpr is not exclusively met in spatial cases! 
     986                        //Need to distinguish thematic and spatial!! 
     987 
     988                        //One way to do it: Check for label column in children of expression. If none exists: No way sth spatial is involved! 
    979989                        else if(expr instanceof MathExpr) 
    980990                        { 
    981991                                try { 
    982                                         sqlExpr = sql.getNumericExprFactory().createNumericExpr(expr); 
    983                                         reference.getSpatialConstructs().put(name, sqlExpr); 
    984                                         iter.remove(); 
     992                                        if(!thematicExpression(expr)) 
     993                                        { 
     994                                                sqlExpr = sql.getNumericExprFactory().createNumericExpr(expr); 
     995 
     996                                                reference.getSpatialConstructs().put(name, sqlExpr); 
     997                                                iter.remove(); 
     998                                        } 
    985999                                } catch (UnsupportedRdbmsOperatorException e) { 
    9861000                                        e.printStackTrace(); 
     
    10161030 
    10171031                } 
     1032        } 
     1033 
     1034        //Checking that no spatial function exists in this metric expression 
     1035        private boolean thematicExpression(ValueExpr expr) 
     1036        { 
     1037                if(expr instanceof UnaryValueOperator) 
     1038                { 
     1039                        return thematicExpression(((UnaryValueOperator) expr).getArg()); 
     1040                } 
     1041                else if(expr instanceof BinaryValueOperator) 
     1042                { 
     1043                        return thematicExpression(((BinaryValueOperator) expr).getLeftArg()) && 
     1044                                   thematicExpression(((BinaryValueOperator) expr).getRightArg()); 
     1045                } 
     1046                else 
     1047                { 
     1048                        if(expr instanceof FunctionCall) 
     1049                        { 
     1050                                Function function = FunctionRegistry.getInstance().get(((FunctionCall) expr).getURI()); 
     1051                                if(function instanceof SpatialMetricFunc) 
     1052                                { 
     1053                                        return false; 
     1054                                } 
     1055                        } 
     1056                        return true; 
     1057                } 
     1058 
    10181059        } 
    10191060 
     
    11741215        { 
    11751216                int mbbCounter = 0; 
    1176 //              super.meet(node); 
     1217                //              super.meet(node); 
    11771218                if (!(node.getArg() instanceof GeneralDBSelectQuery)) 
    11781219                        //In other words, I have encountered having/groupby 
     
    12011242                                                                Extension ext = new Extension(); 
    12021243                                                                ext.addElement(extElem); 
    1203 //                                                              ((Projection)(node.getParentNode())).setArg(ext); 
    1204 //                                                              ext.setArg(node); 
     1244                                                                //                                                              ((Projection)(node.getParentNode())).setArg(ext); 
     1245                                                                //                                                              ext.setArg(node); 
    12051246                                                                Extension tmpExt = (Extension) node.getArg(); 
    12061247                                                                node.setArg(ext); 
    12071248                                                                ext.setArg(tmpExt); 
    1208                                                                  
     1249 
    12091250                                                        } 
    1210 //                                                      else if(node.getParentNode() instanceof Projection) 
    1211 //                                                      { 
    1212 //                                                              Extension ext = new Extension(); 
    1213 //                                                              ext.addElement(extElem); 
    1214 //                                                              ((Projection)(node.getParentNode())).setArg(ext); 
    1215 //                                                              ext.setArg(node); 
    1216 //                                                      } 
     1251                                                        //                                                      else if(node.getParentNode() instanceof Projection) 
     1252                                                        //                                                      { 
     1253                                                        //                                                              Extension ext = new Extension(); 
     1254                                                        //                                                              ext.addElement(extElem); 
     1255                                                        //                                                              ((Projection)(node.getParentNode())).setArg(ext); 
     1256                                                        //                                                              ext.setArg(node); 
     1257                                                        //                                                      } 
    12171258                                                        else if(node.getParentNode() instanceof Extension) 
    12181259                                                        { 
     
    12361277                                                Extension ext = new Extension(); 
    12371278                                                ext.addElement(extElem); 
    1238 //                                              ((Projection)(node.getParentNode())).setArg(ext); 
    1239 //                                              ext.setArg(node); 
     1279                                                //                                              ((Projection)(node.getParentNode())).setArg(ext); 
     1280                                                //                                              ext.setArg(node); 
    12401281                                                Extension tmpExt = (Extension) node.getArg(); 
    12411282                                                node.setArg(ext); 
    12421283                                                ext.setArg(tmpExt); 
    12431284                                        } 
    1244 //                                      else if(node.getParentNode() instanceof Projection) 
    1245 //                                      { 
    1246 //                                              Extension ext = new Extension(); 
    1247 //                                              ext.addElement(extElem); 
    1248 //                                              ((Projection)(node.getParentNode())).setArg(ext); 
    1249 //                                              ext.setArg(node); 
    1250 //                                      } 
     1285                                        //                                      else if(node.getParentNode() instanceof Projection) 
     1286                                        //                                      { 
     1287                                        //                                              Extension ext = new Extension(); 
     1288                                        //                                              ext.addElement(extElem); 
     1289                                        //                                              ((Projection)(node.getParentNode())).setArg(ext); 
     1290                                        //                                              ext.setArg(node); 
     1291                                        //                                      } 
    12511292                                        else if(node.getParentNode() instanceof Extension) 
    12521293                                        { 
  • postgis/src/main/java/org/openrdf/sail/postgis/evaluation/PostGISQueryBuilder.java

    r42 r43  
    285285 
    286286        //FIXME my addition from here on 
    287         @Override 
    288         public GeneralDBQueryBuilder construct(GeneralDBSqlExpr expr) 
    289                         throws UnsupportedRdbmsOperatorException 
     287         
     288        //Issue with this function: crashes when MathExpr is present in Select but does not 
     289        //involve spatial variables! must escape this somehow 
     290        @Override 
     291        public GeneralDBQueryBuilder construct(GeneralDBSqlExpr expr) throws UnsupportedRdbmsOperatorException 
    290292                        { 
    291293                if(!(expr instanceof GeneralDBSqlSpatialMetricBinary)  
Note: See TracChangeset for help on using the changeset viewer.