Дмитриев Даниил, 494, CQL + CQL-EX

ocksumoron/pom.xml

@@ -19,7 +19,7 @@
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
-      <version>3.8.1</version>
+      <version>4.12</version>
       <scope>test</scope>
     </dependency>
     <dependency>
@@ -38,5 +38,15 @@
           <artifactId>jsoup</artifactId>
           <version>1.8.3</version>
       </dependency>
+      <dependency>
+          <groupId>com.google.guava</groupId>
+          <artifactId>guava</artifactId>
+          <version>18.0</version>
+      </dependency>
+      <dependency>
+          <groupId>com.h2database</groupId>
+          <artifactId>h2</artifactId>
+          <version>1.4.190</version>
+      </dependency>
   </dependencies>
 </project>

ocksumoron/src/main/java/ru/fizteh/fivt/students/ocksumoron/collectionquery/Aggregates.java

@@ -0,0 +1,63 @@
+package ru.fizteh.fivt.students.ocksumoron.collectionquery;
+
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Function;
+
+public class Aggregates {
+    public static <T> Function<T, Integer> count(Function<T, ?> expression) {
+        return new Count<>(expression);
+    }
+
+    public static <T> Function<T, Double> avg(Function<T, ? extends Number> expression) {
+        return new Avg<>(expression);
+    }
+
+    public interface Aggregator<T, C> extends Function<T, C> {
+        C apply(List<T> list);
+    }
+
+    public static class Count<T> implements Aggregator<T, Integer> {
+
+        private Function<T, ?> function;
+        public Count(Function<T, ?> expression) {
+            this.function = expression;
+        }
+
+        @Override
+        public Integer apply(List<T> list) {
+            Set<Object> distinctedList = new HashSet<>();
+            list.stream().filter(e -> !distinctedList.contains(function.apply(e))).forEach(e -> {
+                distinctedList.add(function.apply(e));
+            });
+            return distinctedList.size();
+        }
+        @Override
+        public Integer apply(T t) {
+            return null;
+        }
+    }
+
+    public static class Avg<T> implements Aggregator<T, Double> {
+        private Function<T, ? extends Number> function;
+        public Avg(Function<T, ? extends Number> expression) {
+            this.function = expression;
+        }
+
+        @Override
+        public Double apply(List<T> list) {
+            Double result = 0.0;
+            for (T e : list) {
+                result += function.apply(e).floatValue();
+            }
+            return result / list.size();
+        }
+
+        @Override
+        public Double apply(T t) {
+            return null;
+        }
+    }
+}

ocksumoron/src/main/java/ru/fizteh/fivt/students/ocksumoron/collectionquery/Conditions.java

@@ -0,0 +1,10 @@
+package ru.fizteh.fivt.students.ocksumoron.collectionquery;
+
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+public class Conditions<T> {
+    public static <T> Predicate<T> rlike(Function<T, String> expression, String regexp) {
+        return element -> expression.apply(element).matches(regexp);
+    }
+}

ocksumoron/src/main/java/ru/fizteh/fivt/students/ocksumoron/collectionquery/OrderByConditions.java

@@ -0,0 +1,32 @@
+package ru.fizteh.fivt.students.ocksumoron.collectionquery;
+
+import java.util.Comparator;
+import java.util.function.Function;
+
+public class OrderByConditions {
+
+    /**
+     * Ascending comparator.
+     *
+     * @param expression
+     * @param <T>
+     * @param <R>
+     * @return
+     */
+    public static <T, R extends Comparable<R>> Comparator<T> asc(Function<T, R> expression) {
+        return (o1, o2) -> expression.apply(o1).compareTo(expression.apply(o2));
+    }
+
+    /**
+     * Descending comparator.
+     *
+     * @param expression
+     * @param <T>
+     * @param <R>
+     * @return
+     */
+    public static <T, R extends Comparable<R>> Comparator<T> desc(Function<T, R> expression) {
+        return (o1, o2) -> expression.apply(o2).compareTo(expression.apply(o1));
+    }
+
+}

ocksumoron/src/main/java/ru/fizteh/fivt/students/ocksumoron/collectionquery/Sources.java

@@ -0,0 +1,19 @@
+package ru.fizteh.fivt.students.ocksumoron.collectionquery;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Sources {
+
+    /**
+     * @param items
+     * @param <T>
+     * @return
+     */
+    @SafeVarargs
+    public static <T> List<T> list(T... items) {
+        return new ArrayList<>(Arrays.asList(items));
+    }
+
+}

ocksumoron/src/main/java/ru/fizteh/fivt/students/ocksumoron/collectionquery/impl/FromStmt.java

@@ -0,0 +1,82 @@
+package ru.fizteh.fivt.students.ocksumoron.collectionquery.impl;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.function.BiPredicate;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class FromStmt<T> {
+    private List<T> list = new ArrayList<T>();
+
+    public FromStmt(Iterable<T> iterable) {
+        for (T curr : iterable) {
+            list.add(curr);
+        }
+    }
+
+    public static <T> FromStmt<T> from(Iterable<T> iterable) {
+        return new FromStmt<>(iterable);
+    }
+
+    @SafeVarargs
+    public final <R> SelectStmt<T, R> select(Class<R> clazz, Function<T, ?>... functions) {
+        return new SelectStmt<>(list, clazz, false, functions);
+    }
+
+    @SafeVarargs
+    public final <R> SelectStmt<T, R> selectDistinct(Class<R> clazz, Function<T, ?>... functions) {
+        return new SelectStmt<>(list, clazz, true, functions);
+    }
+
+    public final <F, S> SelectStmt<T, Tuple<F, S>> select(Function<T, F> first, Function<T, S> second) {
+        return new SelectStmt<>(list, false, first, second);
+    }
+
+    public <J> JoinClause<T, J> join(Iterable<J> iterable) {
+        return new JoinClause<T, J>(list, iterable);
+    }
+
+    public class JoinClause<S, J> {
+        private List<S> firstList = new ArrayList<>();
+        private List<J> secondList = new ArrayList<>();
+        private List<Tuple<S, J>> list = new ArrayList<>();
+
+        public JoinClause(List<S> firstList, Iterable<J> secondList) {
+            this.firstList.addAll(firstList.stream().collect(Collectors.toList()));
+            for (J curr : secondList) {
+                this.secondList.add(curr);
+            }
+        }
+
+        public FromStmt<Tuple<S, J>> on(BiPredicate<S, J> condition) {
+            for (S first : firstList) {
+                list.addAll(secondList.stream().filter(second -> condition.test(first, second))
+                        .map(second -> new Tuple<>(first, second)).collect(Collectors.toList()));
+            }
+            return new FromStmt<>(list);
+        }
+
+        public <K extends Comparable<?>> FromStmt<Tuple<S, J>> on(
+                Function<S, K> leftKey,
+                Function<J, K> rightKey) {
+            HashMap<K, List<J>> map = new HashMap<>();
+            for (J e : secondList) {
+                K key = rightKey.apply(e);
+                if (!map.containsKey(key)) {
+                    map.put(key, new ArrayList<>());
+                }
+                map.get(key).add(e);
+            }
+            for (S first : firstList) {
+                K key = leftKey.apply(first);
+                if (map.containsKey(key)) {
+                    List<J> second = map.get(key);
+                    second.forEach(s -> list.add(new Tuple<>(first, s)));
+                }
+            }
+            return new FromStmt<>(list);
+        }
+    }
+}

ocksumoron/src/main/java/ru/fizteh/fivt/students/ocksumoron/collectionquery/impl/Query.java

@@ -0,0 +1,8 @@
+package ru.fizteh.fivt.students.ocksumoron.collectionquery.impl;
+
+import java.lang.reflect.InvocationTargetException;
+
+public interface Query<R> {
+    Iterable<R> execute() throws NoSuchMethodException,
+            IllegalAccessException, InvocationTargetException, InstantiationException;
+}