Module Tests, Мамаева Дарья, 494

mamaevads/pom.xml

@@ -21,6 +21,19 @@
       <artifactId>junit</artifactId>
       <version>3.8.1</version>
     </dependency>
+    <dependency>
+      <groupId>com.beust</groupId>
+      <artifactId>jcommander</artifactId>
+      <version>1.48</version>
+    </dependency>
+
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.12</version>
+      <scope>test</scope>
+    </dependency>
+
     <dependency>
       <groupId>org.twitter4j</groupId>
       <artifactId>twitter4j-stream</artifactId>
@@ -31,5 +44,10 @@
       <artifactId>jcommander</artifactId>
       <version>1.48</version>
     </dependency>
+    <dependency>
+      <groupId>com.h2database</groupId>
+      <artifactId>h2</artifactId>
+      <version>1.4.190</version>
+    </dependency>
   </dependencies>
 </project>

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

@@ -0,0 +1,102 @@
+package ru.fizteh.fivt.students.mamaevads.collectionquery;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.function.Function;
+
+
+public class Aggregates {
+
+    public interface Aggregate<C, T> extends Function<C, T> {
+        T forGroup(Set<C> set);
+    }
+
+    private static <C, T> Collection<T> getValues(Collection<C> set, Function<C, T> expression) {
+        Set<T> values = new HashSet<>();
+        for (C element : set) {
+            values.add(expression.apply(element));
+        }
+        return values;
+    }
+
+    public static <C, T extends Comparable<T>> Aggregate<C, T> max(Function<C, T> expression) {
+        return new Aggregate<C, T>() {
+
+            @Override
+            public T apply(C element) {
+                return (T) expression.apply(element);
+            }
+
+            @Override
+            public T forGroup(Set<C> set) throws ClassCastException, NoSuchElementException {
+                return Collections.max(getValues(set, expression));
+            }
+        };
+    }
+
+    public static <C, T extends Comparable<T>> Aggregate<C, T> min(Function<C, T> expression) {
+        return new Aggregate<C, T>() {
+
+            @Override
+            public T apply(C element) {
+                return (T) expression.apply(element);
+            }
+
+            @Override
+            public T forGroup(Set<C> set) throws ClassCastException, NoSuchElementException {
+                return Collections.min(getValues(set, expression));
+            }
+        };
+    }
+
+    public static <C, T extends Comparable<T>> Aggregate<C, Long> count(Function<C, T> expression) {
+        return new Aggregate<C, Long>() {
+
+            @Override
+            public Long apply(C element) {
+                return Long.valueOf(1);
+            }
+
+            @Override
+            public Long forGroup(Set<C> set) {
+                return (long) set.size();
+            }
+        };
+    }
+
+    public static <C, T extends Number & Comparable<T>> Aggregate<C, T> avg(Function<C, T> expression) {
+        return new Aggregate<C, T>() {
+
+            @Override
+            public T apply(C element) {
+                return expression.apply(element);
+            }
+
+            @Override
+            public T forGroup(Set<C> set) throws ClassCastException, NoSuchElementException {
+                if (set.isEmpty()) {
+                    throw new NoSuchElementException("set is empty");
+                }
+                T sample = expression.apply(set.iterator().next());
+                if (sample instanceof Long || sample instanceof Integer || sample instanceof Short) {
+                    long average = 0;
+                    for (C element : set) {
+                        average += (Long) (expression.apply(element));
+                    }
+                    return (T) Long.valueOf(average / set.size());
+                } else if (sample instanceof Float || sample instanceof Double) {
+                    double average = 0;
+                    for (C element : set) {
+                        average += (Double) (expression.apply(element));
+                    }
+                    return (T) Double.valueOf(average / set.size());
+                }
+                throw new ClassCastException("wrong type");
+            }
+        };
+    }
+
+}

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

@@ -0,0 +1,22 @@
+package ru.fizteh.fivt.students.mamaevads.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 new Predicate<T>() {
+
+            @Override
+            public boolean test(T element) {
+                return expression.apply(element).matches(regexp);
+            }
+        };
+    }
+
+    public static <T> Predicate<T> like(Function<T, String> expression, String pattern) {
+        throw new UnsupportedOperationException();
+    }
+
+}

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

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

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

@@ -0,0 +1,54 @@
+package ru.fizteh.fivt.students.mamaevads.collectionquery;
+
+        import java.io.FileInputStream;
+        import java.io.IOException;
+        import java.io.InputStream;
+        import java.nio.file.Path;
+        import java.util.Arrays;
+        import java.util.HashSet;
+        import java.util.List;
+        import java.util.Set;
+        import java.util.stream.Stream;
+
+public class Sources {
+
+    @SafeVarargs
+    public static <T> List<T> list(T... items) {
+        return Arrays.asList(items);
+    }
+
+    @SafeVarargs
+    public static <T> Set<T> set(T... items) {
+        Set<T> result = new HashSet<>();
+        for (T element : items) {
+            result.add(element);
+        }
+        return result;
+    }
+
+    static final int READ_BLOCK_SIZE = 100;
+
+
+    public static <T> Stream<T> lines(InputStream inputStream) throws IOException, ClassCastException {
+        StringBuilder builder = new StringBuilder();
+        byte[] data = new byte[READ_BLOCK_SIZE];
+        int readed = inputStream.read(data);
+        while (readed > 0) {
+            builder.append(data);
+            readed = inputStream.read(data);
+        }
+        inputStream.close();
+        String[] lines = builder.toString().split("[\n]");
+        Stream.Builder<T> stream = Stream.builder();
+        for (String line : lines) {
+            stream.add((T) line);
+        }
+        return stream.build();
+    }
+
+    public static <T> Stream<T> lines(Path file) throws ClassCastException, IOException {
+        InputStream input = new FileInputStream(file.toFile());
+        return lines(input);
+    }
+
+}

mamaevads/src/main/java/ru/fizteh/fivt/students/mamaevads/collectionquery/impl/CollectionQueryExecuteException.java

@@ -0,0 +1,9 @@
+package ru.fizteh.fivt.students.mamaevads.collectionquery.impl;
+
+public class CollectionQueryExecuteException extends Exception {
+
+    CollectionQueryExecuteException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
+

mamaevads/src/main/java/ru/fizteh/fivt/students/mamaevads/collectionquery/impl/CollectionQuerySyntaxException.java

@@ -0,0 +1,13 @@
+package ru.fizteh.fivt.students.mamaevads.collectionquery.impl;
+
+public class CollectionQuerySyntaxException extends Exception {
+
+    CollectionQuerySyntaxException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    CollectionQuerySyntaxException(String message) {
+        super(message);
+    }
+}
+

mamaevads/src/main/java/ru/fizteh/fivt/students/mamaevads/collectionquery/impl/FinalRow.java

@@ -0,0 +1,33 @@
+package ru.fizteh.fivt.students.mamaevads.collectionquery.impl;
+
+import java.util.HashSet;
+import java.util.Set;
+
+class FinalRow<T, R> {
+    private R row;
+    private Set<T> from;
+
+    FinalRow(R newRow, T elementFrom) {
+        from = new HashSet<T>();
+        from.add(elementFrom);
+        row = newRow;
+    }
+
+    public R get() {
+        return row;
+    }
+
+    public Set<T> getFrom() {
+        return from;
+    }
+
+    public T getAnyFrom() {
+        return from.iterator().next();
+    }
+
+    public void updateRow(R newRow) {
+        row = newRow;
+    }
+}
+
+