Performance improvements

pom.xml

@@ -267,6 +267,12 @@
 		  <artifactId>httpclient</artifactId>
 		  <version>4.5.13</version>
 		</dependency>
+        <dependency>
+            <groupId>org.skyscreamer</groupId>
+            <artifactId>jsonassert</artifactId>
+            <version>1.5.1</version>
+            <scope>test</scope>
+        </dependency>
 		<!--<dependency>
 		    <groupId>edu.vanderbilt.accre</groupId>
 		    <artifactId>laurelin</artifactId>

src/main/java/org/rumbledb/compiler/InferTypeVisitor.java

@@ -1,5 +1,14 @@
 package org.rumbledb.compiler;
 
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
 import org.apache.spark.sql.AnalysisException;
 import org.apache.spark.sql.types.StructType;
 import org.rumbledb.config.RumbleRuntimeConfiguration;
@@ -112,13 +121,6 @@
 import org.rumbledb.types.SequenceType;
 import sparksoniq.spark.SparkSessionManager;
 
-import java.net.URI;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 
 
 /**
@@ -257,8 +259,41 @@ public StaticContext visitCommaExpression(CommaExpression expression, StaticCont
                 if (inferredType.isEmptySequence()) {
                     inferredType = childExpressionInferredType;
                 } else {
-                    ItemType resultingItemType = inferredType.getItemType()
-                        .findLeastCommonSuperTypeWith(childExpressionInferredType.getItemType());
+                    ItemType resultingItemType;
+                    if (
+                        inferredType.getItemType().isObjectItemType()
+                            && childExpressionInferredType.getItemType().isObjectItemType()
+                    ) {
+                        final Map<String, FieldDescriptor> currentItemTypeObject = inferredType.getItemType()
+                            .getObjectContentFacet();
+                        resultingItemType = (currentItemTypeObject.keySet().size() == childExpressionInferredType
+                            .getItemType()
+                            .getObjectContentFacet()
+                            .keySet()
+                            .size()
+                            && currentItemTypeObject
+                                .keySet()
+                                .stream()
+                                .allMatch(
+                                    key -> childExpressionInferredType.getItemType()
+                                        .getObjectContentFacet()
+                                        .containsKey(key)
+                                        && currentItemTypeObject
+                                            .get(key)
+                                            .getType()
+                                            .equals(
+                                                childExpressionInferredType.getItemType()
+                                                    .getObjectContentFacet()
+                                                    .get(key)
+                                                    .getType()
+                                            )
+                                ))
+                                    ? inferredType.getItemType()
+                                    : BuiltinTypesCatalogue.objectItem;
+                    } else {
+                        resultingItemType = inferredType.getItemType()
+                            .findLeastCommonSuperTypeWith(childExpressionInferredType.getItemType());
+                    }
                     SequenceType.Arity resultingArity =
                         ((inferredType.getArity() == SequenceType.Arity.OneOrZero
                             || inferredType.getArity() == SequenceType.Arity.ZeroOrMore)
@@ -380,7 +415,33 @@ public StaticContext visitObjectConstructor(ObjectConstructorExpression expressi
                 }
             }
         }
-        expression.setStaticSequenceType(new SequenceType(BuiltinTypesCatalogue.objectItem));
+        if (
+            expression.getKeys() != null
+                && expression.getKeys()
+                    .stream()
+                    .allMatch(key -> key instanceof StringLiteralExpression)
+                && expression.getValues()
+                    .stream()
+                    .map(Expression::getStaticSequenceType)
+                    .allMatch(type -> type.getArity() == SequenceType.Arity.One)
+        ) {
+            expression.setStaticSequenceType(
+                new SequenceType(
+                        ItemTypeFactory.createAnonymousObjectType(
+                            expression.getKeys()
+                                .stream()
+                                .map(key -> ((StringLiteralExpression) key).getValue())
+                                .collect(Collectors.toList()),
+                            expression.getValues()
+                                .stream()
+                                .map(value -> value.getStaticSequenceType().getItemType())
+                                .collect(Collectors.toList())
+                        )
+                )
+            );
+        } else {
+            expression.setStaticSequenceType(new SequenceType(BuiltinTypesCatalogue.objectItem));
+        }
         return argument;
     }
 
@@ -480,6 +541,29 @@ private boolean tryAnnotateSpecificFunctions(FunctionCallExpression expression,
             expression.setStaticSequenceType(args.get(0).getStaticSequenceType());
             return true;
         }
+        // handle 'size' function
+        if (
+            functionName.equals(Name.createVariableInDefaultFunctionNamespace("size"))
+                && args.get(0).getStaticSequenceType().getArity() == SequenceType.Arity.One
+        ) {
+            // set output type to 'Integer' if inputType is 'Array'
+            expression.setStaticSequenceType(
+                new SequenceType(BuiltinTypesCatalogue.integerItem, SequenceType.Arity.One)
+            );
+            return true;
+        }
+
+        if (functionName.equals(Name.createVariableInDefaultFunctionNamespace("sum"))) {
+            expression.setStaticSequenceType(
+                new SequenceType(
+                        args.get(0).getStaticSequenceType().getItemType(),
+                        args.get(0).getStaticSequenceType().getArity() == SequenceType.Arity.OneOrMore
+                            ? SequenceType.Arity.One
+                            : SequenceType.Arity.OneOrZero
+                )
+            );
+            return true;
+        }
 
         return false;
     }
@@ -657,7 +741,9 @@ public StaticContext visitCastExpression(CastExpression expression, StaticContex
                 expression.getMetadata()
             );
         }
-
+        if (expressionSequenceType.getArity() == SequenceType.Arity.One) {
+            castedSequenceType = new SequenceType(castedSequenceType.getItemType(), SequenceType.Arity.One);
+        }
         expression.setStaticSequenceType(castedSequenceType);
         return argument;
     }
@@ -701,6 +787,9 @@ public StaticContext visitTreatExpression(TreatExpression expression, StaticCont
             );
         }
 
+        if (SequenceType.ITEM_STAR.equals(treatedSequenceType)) {
+            treatedSequenceType = expressionSequenceType;
+        }
         expression.setStaticSequenceType(treatedSequenceType);
         return argument;
     }
@@ -880,6 +969,8 @@ public StaticContext visitAdditiveExpr(AdditiveExpression expression, StaticCont
     private ItemType resolveNumericType(ItemType left, ItemType right) {
         if (left.equals(BuiltinTypesCatalogue.doubleItem) || right.equals(BuiltinTypesCatalogue.doubleItem)) {
             return BuiltinTypesCatalogue.doubleItem;
+        } else if (left.equals(BuiltinTypesCatalogue.floatItem) || right.equals(BuiltinTypesCatalogue.floatItem)) {
+            return BuiltinTypesCatalogue.floatItem;
         } else if (left.equals(BuiltinTypesCatalogue.decimalItem) || right.equals(BuiltinTypesCatalogue.decimalItem)) {
             return BuiltinTypesCatalogue.decimalItem;
         } else {
@@ -1619,7 +1710,7 @@ public StaticContext visitObjectLookupExpression(ObjectLookupExpression expressi
             : SequenceType.Arity.ZeroOrMore;
 
         ItemType inferredType = BuiltinTypesCatalogue.item;
-        // if we have a specific object type and a string literal as key try perform better inference
+        // if we have a specific object type and a string literal as key try to perform better inference
         if (
             mainType.getItemType().isObjectItemType()
                 && (expression.getLookupExpression() instanceof StringLiteralExpression)
@@ -1669,7 +1760,14 @@ public StaticContext visitArrayUnboxingExpression(ArrayUnboxingExpression expres
                 expression.getMetadata()
             );
         }
-
+        if (mainType.getItemType().isArrayItemType()) {
+            SequenceType sequenceType = new SequenceType(
+                    mainType.getItemType().getArrayContentFacet(),
+                    SequenceType.Arity.ZeroOrMore
+            );
+            expression.setStaticSequenceType(sequenceType);
+            return argument;
+        }
         expression.setStaticSequenceType(SequenceType.createSequenceType("item*"));
         return argument;
     }
@@ -1889,18 +1987,12 @@ public StaticContext visitForClause(ForClause expression, StaticContext argument
         basicChecks(inferredType, expression.getClass().getSimpleName(), true, false, expression.getMetadata());
         if (inferredType.isEmptySequence()) {
             if (!expression.isAllowEmpty()) {
-                if (
-                    !expression.getVariableName().equals(Name.TEMP_VAR1)
-                        && !expression.getVariableName().equals(Name.TEMP_VAR2)
-                ) {
-                    // for sure we will not have any tuple to process and return the empty sequence
-                    throwStaticTypeException(
-                        "In for clause Inferred type is empty sequence, empty is not allowed, so the result returned is for sure () and this is not a CommaExpression",
-                        ErrorCode.StaticallyInferredEmptySequenceNotFromCommaExpression,
-                        expression.getMetadata()
-                    );
-                }
-                inferredType = new SequenceType(BuiltinTypesCatalogue.atomicItem);
+                // for sure we will not have any tuple to process and return the empty sequence
+                throwStaticTypeException(
+                    "In for clause Inferred type is empty sequence, empty is not allowed, so the result returned is for sure () and this is not a CommaExpression",
+                    ErrorCode.StaticallyInferredEmptySequenceNotFromCommaExpression,
+                    expression.getMetadata()
+                );
             }
         } else {
             // we take the single arity version of the inferred type or optional arity if we allow empty and the
@@ -1943,7 +2035,7 @@ public StaticContext visitLetClause(LetClause expression, StaticContext argument
             expression.getVariableName(),
             expression.getMetadata()
         );
-
+        expression.setStaticType(inferredType);
         return argument;
     }
 
@@ -2022,7 +2114,7 @@ public StaticContext visitGroupByClause(GroupByClause expression, StaticContext
             groupingVars.add(groupByVar.getVariableName());
         }
 
-        // finally if there was a for clause we need to change the arity of the variables binded so far in the flowr
+        // finally if there was a for clause we need to change the arity of the variables bound so far in the flwor
         // expression, from ? to * and from 1 to +
         // excluding the grouping variables
         StaticContext nextClauseStaticContext = expression.getNextClause().getStaticContext();