diff --git a/projects/JenkaEff/pom.xml b/projects/JenkaEff/pom.xml new file mode 100644 index 0000000..2ebeb66 --- /dev/null +++ b/projects/JenkaEff/pom.xml @@ -0,0 +1,26 @@ + + + 4.0.0 + + ru.mipt.diht.students + parent + 1.0-SNAPSHOT + + ru.mipt.diht.students + JenkaEff + 1.0-SNAPSHOT + JenkaEff + http://maven.apache.org + + UTF-8 + + + + junit + junit + 3.8.1 + test + + + diff --git a/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/Aggregates.java b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/Aggregates.java new file mode 100644 index 0000000..ff8b738 --- /dev/null +++ b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/Aggregates.java @@ -0,0 +1,62 @@ +package ru.fizteh.fivt.students.JenkaEff.CollectionQuery; + +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.function.Function; + +public class Aggregates { + public static Function count(Function expression) { + return new Count<>(expression); + } + + public static Function avg(Function expression) { + return new Avg<>(expression); + } + + public interface Aggregator extends Function { + C apply(List list); + } + + public static class Count implements Aggregator { + + private Function function; + public Count(Function expression) { + this.function = expression; + } + + @Override + public Integer apply(List list) { + Set 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 implements Aggregator { + private Function function; + public Avg(Function expression) { + this.function = expression; + } + + @Override + public Double apply(List 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; + } + } +} \ No newline at end of file diff --git a/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/Conditions.java b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/Conditions.java new file mode 100644 index 0000000..89b72e3 --- /dev/null +++ b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/Conditions.java @@ -0,0 +1,10 @@ +package ru.fizteh.fivt.students.JenkaEff.CollectionQuery; + +import java.util.function.Function; +import java.util.function.Predicate; + +public class Conditions { + public static Predicate rlike(Function expression, String regexp) { + return e -> expression.apply(e).matches(regexp); + } +} \ No newline at end of file diff --git a/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/OrderByConditions.java b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/OrderByConditions.java new file mode 100644 index 0000000..362687a --- /dev/null +++ b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/OrderByConditions.java @@ -0,0 +1,14 @@ +package ru.fizteh.fivt.students.JenkaEff.CollectionQuery; + +import java.util.Comparator; +import java.util.function.Function; + +public class OrderByConditions { + public static > Comparator asc(Function expression) { + return (e1, e2) -> expression.apply(e1).compareTo(expression.apply(e2)); + } + + public static > Comparator desc(Function expression) { + return (e1, e2) -> expression.apply(e2).compareTo(expression.apply(e1)); + } +} \ No newline at end of file diff --git a/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/Sources.java b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/Sources.java new file mode 100644 index 0000000..ba88ebf --- /dev/null +++ b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/Sources.java @@ -0,0 +1,12 @@ +package ru.fizteh.fivt.students.JenkaEff.CollectionQuery; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class Sources { + @SafeVarargs + public static List list(T... items) { + return new ArrayList<>(Arrays.asList(items)); + } +} \ No newline at end of file diff --git a/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/impl/FromStmt.java b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/impl/FromStmt.java new file mode 100644 index 0000000..39903d0 --- /dev/null +++ b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/impl/FromStmt.java @@ -0,0 +1,82 @@ +package ru.fizteh.fivt.students.JenkaEff.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 { + private List list = new ArrayList(); + + public FromStmt(Iterable iterable) { + for (T curr : iterable) { + list.add(curr); + } + } + + public static FromStmt from(Iterable iterable) { + return new FromStmt<>(iterable); + } + + @SafeVarargs + public final SelectStmt select(Class clazz, Function... functions) { + return new SelectStmt<>(list, clazz, false, functions); + } + + @SafeVarargs + public final SelectStmt selectDistinct(Class clazz, Function... functions) { + return new SelectStmt<>(list, clazz, true, functions); + } + + public final SelectStmt> select(Function first, Function second) { + return new SelectStmt<>(list, false, first, second); + } + + public JoinClause join(Iterable iterable) { + return new JoinClause(list, iterable); + } + + public class JoinClause { + private List firstList = new ArrayList<>(); + private List secondList = new ArrayList<>(); + private List> list = new ArrayList<>(); + + public JoinClause(List firstList, Iterable secondList) { + this.firstList.addAll(firstList.stream().collect(Collectors.toList())); + for (J curr : secondList) { + this.secondList.add(curr); + } + } + + public FromStmt> on(BiPredicate 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 > FromStmt> on( + Function leftKey, + Function rightKey) { + HashMap> 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 second = map.get(key); + second.forEach(s -> list.add(new Tuple<>(first, s))); + } + } + return new FromStmt<>(list); + } + } +} diff --git a/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/impl/Pair.java b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/impl/Pair.java new file mode 100644 index 0000000..6051db6 --- /dev/null +++ b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/impl/Pair.java @@ -0,0 +1,23 @@ +package ru.fizteh.fivt.students.JenkaEff.CollectionQuery.impl; + +public class Pair { + private T key; + private R value; + Pair(T k, R v) { + key = k; + value = v; + } + public T getKey() { + return key; + } + public void setKey(T key) { + this.key = key; + } + public R getValue() { + return value; + } + public void setValue(R value) { + this.value = value; + } + +} diff --git a/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/impl/SelectStmt.java b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/impl/SelectStmt.java new file mode 100644 index 0000000..0ce4ed6 --- /dev/null +++ b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/impl/SelectStmt.java @@ -0,0 +1,221 @@ +package ru.fizteh.fivt.students.JenkaEff.CollectionQuery.impl; + +import ru.fizteh.fivt.students.JenkaEff.CollectionQuery.impl.Pair; +import ru.fizteh.fivt.students.JenkaEff.CollectionQuery.Aggregates; + +import java.lang.reflect.InvocationTargetException; +import java.util.*; +import java.util.function.Function; +import java.util.function.Predicate; +import java.util.stream.Collectors; + +public class SelectStmt { + private boolean isDistinct; + private Class clazz; + private Function[] functions; + private List list; + private List pastList; + private Predicate wherePredicate; + private Comparator[] orderByComparators; + private Predicate havingPredicate; + private int limit; + private Function[] groupByFunctions; + private CQLComparator cqlComparator; + private boolean isUnion; + private boolean isJoin; + + private void init(List list, Class clazz, boolean isDistinct, Function[] functions, + boolean isUnion, boolean isJoin, List pastList) { + this.list = new ArrayList<>(); + this.list.addAll(list.stream().collect(Collectors.toList())); + this.clazz = clazz; + this.isDistinct = isDistinct; + this.functions = functions; + this.limit = -1; + this.isUnion = isUnion; + this.isJoin = isJoin; + this.pastList = pastList; + } + + @SafeVarargs + public SelectStmt(List list, Class clazz, boolean isDistinct, Function... functions) { + init(list, clazz, isDistinct, functions, false, false, null); + } + + public SelectStmt(List list, boolean isDistinct, Function first, Function second) { + init(list, list.get(0).getClass(), isDistinct, new Function[]{first, second}, false, true, null); + } + + @SafeVarargs + public SelectStmt(List pastList, List list, Class clazz, boolean isDistinct, Function... functions) { + init(list, clazz, isDistinct, functions, true, false, pastList); + } + + public SelectStmt(List pastList, List list, boolean isDistinct, Function first, Function second) { + init(list, list.get(0).getClass(), isDistinct, new Function[]{first, second}, true, true, pastList); + } + + public SelectStmt where(Predicate predicate) { + this.wherePredicate = predicate; + return this; + } + + @SafeVarargs + public final SelectStmt groupBy(Function... functions) { + this.groupByFunctions = functions; + return this; + } + + @SafeVarargs + public final SelectStmt orderBy(Comparator... orderByComparators) { + this.orderByComparators = orderByComparators; + this.cqlComparator = new CQLComparator(orderByComparators); + return this; + } + + public SelectStmt having(Predicate predicate) { + this.havingPredicate = predicate; + return this; + } + + public SelectStmt limit(int amount) { + this.limit = amount; + return this; + } + + public Iterable execute() throws NoSuchMethodException, IllegalAccessException, + InvocationTargetException, InstantiationException { + List result = new ArrayList<>(); + Object[] arguments = new Object[functions.length]; + Class[] clazzes = new Class[functions.length]; + if (wherePredicate != null) { + List filtered = new ArrayList<>(); + list.stream().filter(wherePredicate::test).forEach(filtered::add); + list = filtered; + } + if (groupByFunctions != null) { + Map mapped = new HashMap<>(); + String[] results = new String[groupByFunctions.length]; + List> groupped = new ArrayList<>(); + list.stream().forEach( + element -> { + for (int i = 0; i < groupByFunctions.length; i++) { + results[i] = (String) groupByFunctions[i].apply(element); + } + if (!mapped.containsKey(Objects.hash(results))) { + mapped.put(Objects.hash(results), mapped.size()); + } + groupped.add(new Pair(element, mapped.get(Objects.hash(results)))); + } + ); + List> grouppedList = new ArrayList<>(); + for (int i = 0; i < mapped.size(); i++) { + grouppedList.add(new ArrayList()); + } + + for (Pair element : groupped) { + grouppedList.get(element.getValue()).add(element.getKey()); + } + for (List group : grouppedList) { + for (int i = 0; i < functions.length; i++) { + if (functions[i] instanceof Aggregates.Aggregator) { + arguments[i] = ((Aggregates.Aggregator) functions[i]).apply(group); + } else { + arguments[i] = functions[i].apply(group.get(0)); + } + clazzes[i] = arguments[i].getClass(); + } + if (isJoin) { + Tuple newElement = new Tuple(arguments[0], arguments[1]); + result.add((R) newElement); + } else { + R newElement = (R) clazz.getConstructor(clazzes).newInstance(arguments); + result.add(newElement); + } + } + } else { + for (T element : this.list) { + for (int i = 0; i < functions.length; i++) { + arguments[i] = functions[i].apply(element); + if (functions[i] instanceof Aggregates.Aggregator) { + List currArg = new ArrayList<>(); + currArg.add(element); + arguments[i] = ((Aggregates.Aggregator) functions[i]).apply(currArg); + } else { + arguments[i] = functions[i].apply(element); + } + clazzes[i] = arguments[i].getClass(); + } + if (isJoin) { + Tuple newElement = new Tuple(arguments[0], arguments[1]); + result.add((R) newElement); + } else { + R newElement = (R) clazz.getConstructor(clazzes).newInstance(arguments); + result.add(newElement); + } + } + } + if (havingPredicate != null) { + List filtered = new ArrayList<>(); + result.stream().filter(havingPredicate::test).forEach(filtered::add); + result = filtered; + } + if (isDistinct) { + Set hashes = new HashSet<>(); + List flags = new ArrayList<>(); + for (R element : result) { + if (!hashes.contains(element.toString().hashCode())) { + flags.add(1); + hashes.add(element.toString().hashCode()); + } else { + flags.add(0); + } + } + List distincted = new ArrayList<>(); + for (int i = 0; i < result.size(); i++) { + if (flags.get(i) == 1) { + distincted.add(result.get(i)); + } + } + result = distincted; + } + if (orderByComparators != null) { + result.sort(cqlComparator); + } + if (limit != -1) { + while (result.size() > limit) { + result.remove(result.size() - 1); + } + } + if (isUnion) { + pastList.addAll(result); + result = pastList; + } + return result; + } + + public UnionStmt union() throws InvocationTargetException, NoSuchMethodException, + InstantiationException, IllegalAccessException { + List result = (List) this.execute(); + return new UnionStmt<>(result); + } + + public class CQLComparator implements Comparator { + private Comparator[] orderByComparators; + @SafeVarargs + public CQLComparator(Comparator... orderByComparators) { + this.orderByComparators = orderByComparators; + } + + @Override + public int compare(K first, K second) { + for (Comparator comparator : orderByComparators) { + if (comparator.compare(first, second) != 0) { + return comparator.compare(first, second); + } + } + return 0; + } + } + +} \ No newline at end of file diff --git a/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/impl/Tuple.java b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/impl/Tuple.java new file mode 100644 index 0000000..11d4d53 --- /dev/null +++ b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/impl/Tuple.java @@ -0,0 +1,28 @@ +package ru.fizteh.fivt.students.JenkaEff.CollectionQuery.impl; + +public class Tuple { + + private final F first; + private final S second; + + public Tuple(F first, S second) { + this.first = first; + this.second = second; + } + + public F getFirst() { + return first; + } + + public S getSecond() { + return second; + } + + @Override + public String toString() { + return "Tuple{" + + "first=" + first + + ", second=" + second + + "}\n"; + } +} \ No newline at end of file diff --git a/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/impl/UnionStmt.java b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/impl/UnionStmt.java new file mode 100644 index 0000000..2116a24 --- /dev/null +++ b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/CollectionQuery/impl/UnionStmt.java @@ -0,0 +1,100 @@ +package ru.fizteh.fivt.students.JenkaEff.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 UnionStmt { + private List pastList = new ArrayList<>(); + + public UnionStmt(Iterable iterable) { + for (R curr : iterable) { + pastList.add(curr); + } + } + + public FromClause from(Iterable list) { + return new FromClause(pastList, list); + } + + public class FromClause { + private List pastList = new ArrayList<>(); + private List list = new ArrayList<>(); + + public FromClause(Iterable pastList, Iterable list) { + for (R curr : pastList) { + this.pastList.add(curr); + } + for (S curr : list) { + this.list.add(curr); + } + } + @SafeVarargs + public final SelectStmt select(Class clazz, Function... functions) { + return new SelectStmt((List) pastList, list, clazz, false, functions); + } + + public final SelectStmt> select(Function first, Function second) { + return new SelectStmt>((List>) pastList, list, false, first, second); + } + + @SafeVarargs + public final SelectStmt selectDistinct(Class clazz, Function... functions) { + return new SelectStmt((List) pastList, list, clazz, true, functions); + } + + public JoinClause join(Iterable iterable) { + return new JoinClause(pastList, list, iterable); + } + } + + public class JoinClause { + + private List firstList = new ArrayList<>(); + private List secondList = new ArrayList<>(); + private List pastList = new ArrayList<>(); + private List> list = new ArrayList<>(); + + public JoinClause(List pastList, List firstList, Iterable secondList) { + this.pastList.addAll(pastList.stream().collect(Collectors.toList())); + this.firstList.addAll(firstList.stream().collect(Collectors.toList())); + for (J curr : secondList) { + this.secondList.add(curr); + } + } + + public FromClause, R> on(BiPredicate condition) { + for (F first : firstList) { + for (J second : secondList) { + if (condition.test(first, second)) { + list.add(new Tuple<>(first, second)); + } + } + } + return new FromClause<>(pastList, list); + } + + public > FromClause, R> on( + Function leftKey, + Function rightKey) { + HashMap> 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 (F first : firstList) { + K key = leftKey.apply(first); + if (map.containsKey(key)) { + List second = map.get(key); + second.forEach(s -> list.add(new Tuple<>(first, s))); + } + } + return new FromClause<>(pastList, list); + } + } +} \ No newline at end of file diff --git a/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/MiniORM/src/ru/fizteh/fivt/students/JenkaEff/MiniORM/Column.java b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/MiniORM/src/ru/fizteh/fivt/students/JenkaEff/MiniORM/Column.java new file mode 100644 index 0000000..4b04b30 --- /dev/null +++ b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/MiniORM/src/ru/fizteh/fivt/students/JenkaEff/MiniORM/Column.java @@ -0,0 +1,9 @@ +package ru.fizteh.fivt.students.JenkaEff.MiniORM; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +@Retention(RetentionPolicy.RUNTIME) +public @interface Column { + String name() default ""; +} \ No newline at end of file diff --git a/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/MiniORM/src/ru/fizteh/fivt/students/JenkaEff/MiniORM/DatabaseService.java b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/MiniORM/src/ru/fizteh/fivt/students/JenkaEff/MiniORM/DatabaseService.java new file mode 100644 index 0000000..e978a14 --- /dev/null +++ b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/MiniORM/src/ru/fizteh/fivt/students/JenkaEff/MiniORM/DatabaseService.java @@ -0,0 +1,265 @@ +package ru.fizteh.fivt.students.JenkaEff.MiniORM; + +import org.h2.jdbcx.JdbcConnectionPool; + +import java.io.Closeable; +import java.io.IOException; +import java.io.InputStream; +import java.lang.reflect.Field; +import java.sql.*; +import java.util.*; + +import static ru.fizteh.fivt.students.JenkaEff.MiniORM.NameResolver.isGood; + +public class DatabaseService implements Closeable { + private final String connectionName; + private final String username; + private final String password; + + private Class clazz; + private JdbcConnectionPool pool; + private String tableName; + private Field[] fields; + private int pkIndex = -1; + + String getColumnName(Field f) { + String name = f.getAnnotation(Column.class).name(); + if (name.equals("")) { + return f.getName(); + } + return name; + } + + void init() throws IllegalArgumentException, IOException { + if (!clazz.isAnnotationPresent(Table.class)) { + throw new IllegalArgumentException("no @Table annotation"); + } + + tableName = clazz.getAnnotation(Table.class).name(); + if (tableName.equals("")) { + tableName = clazz.getSimpleName(); + } + + if (!isGood(tableName)) { + throw new IllegalArgumentException("Bad table name"); + } + + Set names = new HashSet<>(); + List fieldsList = new ArrayList<>(); + for (Field f: clazz.getDeclaredFields()) { + if (f.isAnnotationPresent(Column.class)) { + String name = getColumnName(f); + names.add(name); + if (!isGood(name)) { + throw new IllegalArgumentException("Bad column name"); + } + + f.setAccessible(true); + fieldsList.add(f); + if (f.isAnnotationPresent(PrimaryKey.class)) { + if (pkIndex == -1) { + pkIndex = fieldsList.size() - 1; + } else { + throw new + IllegalArgumentException("Several @PrimaryKey"); + } + } + } else if (f.isAnnotationPresent(PrimaryKey.class)) { + throw new + IllegalArgumentException("@PrimaryKey without @Column"); + } + } + + if (names.size() != fieldsList.size()) { + throw new IllegalArgumentException("Duplicate columns"); + } + + fields = new Field[fieldsList.size()]; + fields = fieldsList.toArray(fields); + + try { + Class.forName("org.h2.Driver"); + } catch (ClassNotFoundException e) { + throw new IllegalStateException("No H2 driver found"); + } + + pool = JdbcConnectionPool.create(connectionName, username, password); + } + + DatabaseService(Class newClazz, String properties) throws IOException { + Properties credits = new Properties(); + try (InputStream inputStream = this.getClass().getResourceAsStream(properties)) { + credits.load(inputStream); + } + connectionName = credits.getProperty("connection_name"); + username = credits.getProperty("username"); + password = credits.getProperty("password"); + + clazz = newClazz; + init(); + } + + DatabaseService(Class newClazz) throws IOException { + this(newClazz, "/h2test.properties"); + } + + void createTable() throws SQLException { + StringBuilder queryBuilder = new StringBuilder(); + queryBuilder.append("CREATE TABLE IF NOT EXISTS ").append(tableName).append("("); + for (int i = 0; i < fields.length; ++i) { + if (i != 0) { + queryBuilder.append(", "); + } + queryBuilder.append(getColumnName(fields[i])).append(" ") + .append(H2StringsResolver.resolve(fields[i].getType())); + if (i == pkIndex) { + queryBuilder.append(" PRIMARY KEY"); + } + } + queryBuilder.append(")"); + try (Connection conn = pool.getConnection()) { + conn.createStatement().execute(queryBuilder.toString()); + } + + } + + void dropTable() throws SQLException { + StringBuilder queryBuilder = new StringBuilder(); + queryBuilder.append("DROP TABLE IF EXISTS ").append(tableName); + try (Connection conn = pool.getConnection()) { + conn.createStatement().execute(queryBuilder.toString()); + } + } + + public void insert(T record) throws SQLException, IllegalAccessException { + StringBuilder queryBuilder = new StringBuilder(); + queryBuilder.append("INSERT INTO ").append(tableName).append(" ("); + for (int i = 0; i < fields.length; ++i) { + if (i != 0) { + queryBuilder.append(", "); + } + queryBuilder.append(getColumnName(fields[i])).append(" "); + } + queryBuilder.append(") VALUES ("); + for (int i = 0; i < fields.length; ++i) { + if (i != 0) { + queryBuilder.append(", "); + } + queryBuilder.append("?"); + } + queryBuilder.append(")"); + + try (Connection conn = pool.getConnection()) { + PreparedStatement statement = conn.prepareStatement(queryBuilder.toString()); + for (int i = 0; i < fields.length; ++i) { + statement.setObject(i + 1, fields[i].get(record)); + } + statement.execute(); + } + } + + public void delete(T record) throws IllegalArgumentException, IllegalAccessException, SQLException { + if (pkIndex == -1) { + throw new IllegalArgumentException("NO @PrimaryKey"); + } + StringBuilder queryBuilder = new StringBuilder(); + queryBuilder.append("DELETE FROM ").append(tableName).append(" WHERE ") + .append(fields[pkIndex].getName()).append(" = ?"); + try (Connection conn = pool.getConnection()) { + PreparedStatement statement = conn.prepareStatement(queryBuilder.toString()); + statement.setObject(1, fields[pkIndex].get(record)); + statement.execute(); + } + } + + public void update(T record) throws IllegalArgumentException, SQLException, IllegalAccessException { + if (pkIndex == -1) { + throw new IllegalArgumentException("NO @PrimaryKey"); + } + StringBuilder queryBuilder = new StringBuilder(); + queryBuilder.append("UPDATE ").append(tableName).append(" SET "); + for (int i = 0; i < fields.length; ++i) { + if (i != 0) { + queryBuilder.append(", "); + } + queryBuilder.append(getColumnName(fields[i])).append(" = ?"); + } + queryBuilder.append(" WHERE ").append(getColumnName(fields[pkIndex])) + .append(" = ?"); + + try (Connection conn = pool.getConnection()) { + PreparedStatement statement = conn.prepareStatement(queryBuilder.toString()); + for (int i = 0; i < fields.length; ++i) { + statement.setObject(i + 1, fields[i].get(record)); + } + statement.setObject(fields.length + 1, fields[pkIndex].get(record)); + statement.execute(); + } + } + + public List queryForAll() throws SQLException { + List result = new ArrayList<>(); + + StringBuilder queryBuilder = new StringBuilder(); + queryBuilder.append("SELECT * FROM ").append(tableName); + + try (Connection conn = pool.getConnection()) { + try (ResultSet rs = conn.createStatement().executeQuery(queryBuilder.toString())) { + while (rs.next()) { + T record = clazz.newInstance(); + for (int i = 0; i < fields.length; ++i) { + if (fields[i].getClass().isAssignableFrom(Number.class)) { + Long val = rs.getLong(i + 1); + fields[i].set(record, val); + } else if (fields[i].getType() != String.class) { + fields[i].set(record, rs.getObject(i + 1)); + } else { + Clob data = rs.getClob(i + 1); + fields[i].set(record, data.getSubString(1, (int) data.length())); + } + } + result.add(record); + } + } catch (InstantiationException | IllegalAccessException e) { + throw new IllegalArgumentException("wrong class"); + } + } + return result; + } + + public T queryById(K key) throws IllegalArgumentException, SQLException { + StringBuilder queryBuilder = new StringBuilder(); + queryBuilder.append("SELECT * FROM ").append(tableName).append(" WHERE ") + .append(fields[pkIndex].getName()).append(" = ?"); + try (Connection conn = pool.getConnection()) { + PreparedStatement statement = conn.prepareStatement(queryBuilder.toString()); + statement.setString(1, key.toString()); + try (ResultSet rs = statement.executeQuery()) { + rs.next(); + T record = clazz.newInstance(); + for (int i = 0; i < fields.length; ++i) { + if (fields[i].getClass().isAssignableFrom(Number.class)) { + Long val = rs.getLong(i + 1); + fields[i].set(record, val); + } else if (fields[i].getType() != String.class) { + fields[i].set(record, rs.getObject(i + 1)); + } else { + Clob data = rs.getClob(i + 1); + fields[i].set(record, data.getSubString(1, (int) data.length())); + } + } + return record; + } catch (InstantiationException | IllegalAccessException e) { + throw new IllegalArgumentException("wrong class"); + } + } + + } + + @Override + public void close() throws IOException { + if (pool != null) { + pool.dispose(); + } + } +} \ No newline at end of file diff --git a/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/MiniORM/src/ru/fizteh/fivt/students/JenkaEff/MiniORM/H2StringsResolver.java b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/MiniORM/src/ru/fizteh/fivt/students/JenkaEff/MiniORM/H2StringsResolver.java new file mode 100644 index 0000000..05bdfad --- /dev/null +++ b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/MiniORM/src/ru/fizteh/fivt/students/JenkaEff/MiniORM/H2StringsResolver.java @@ -0,0 +1,39 @@ +package ru.fizteh.fivt.students.JenkaEff.MiniORM; + + +import java.sql.Date; +import java.sql.Time; +import java.sql.Timestamp; +import java.util.HashMap; +import java.util.Map; +import java.util.UUID; + +class H2StringsResolver { + private static Map h2Map; + static { + h2Map = new HashMap<>(); + h2Map.put(Integer.class, "INTEGER"); + h2Map.put(Boolean.class, "BOOLEAN"); + h2Map.put(Byte.class, "TINYINT"); + h2Map.put(Short.class, "SMALLINT"); + h2Map.put(Long.class, "BIGINT"); + h2Map.put(Double.class, "DOUBLE"); + h2Map.put(Float.class, "FLOAT"); + h2Map.put(Time.class, "TIME"); + h2Map.put(Date.class, "DATE"); + h2Map.put(Timestamp.class, "TIMESTAMP"); + h2Map.put(Character.class, "CHAR"); + h2Map.put(String.class, "CLOB"); + h2Map.put(UUID.class, "UUID"); + } + + public static String resolve(Class clazz) { + if (clazz.isArray()) { + return "ARRAY"; + } + if (h2Map.containsKey(clazz)) { + return h2Map.get(clazz); + } + return "OTHER"; + } +} \ No newline at end of file diff --git a/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/MiniORM/src/ru/fizteh/fivt/students/JenkaEff/MiniORM/NameResolver.java b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/MiniORM/src/ru/fizteh/fivt/students/JenkaEff/MiniORM/NameResolver.java new file mode 100644 index 0000000..27e9ffe --- /dev/null +++ b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/MiniORM/src/ru/fizteh/fivt/students/JenkaEff/MiniORM/NameResolver.java @@ -0,0 +1,10 @@ +package ru.fizteh.fivt.students.JenkaEff.MiniORM; + +//import com.google.common.base.CaseFormat; + +class NameResolver { + static final String REGEX = "[A-Za-z0-9_-]*"; + public static Boolean isGood(String name) { + return name.matches(REGEX); + } +} \ No newline at end of file diff --git a/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/MiniORM/src/ru/fizteh/fivt/students/JenkaEff/MiniORM/PrimaryKey.java b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/MiniORM/src/ru/fizteh/fivt/students/JenkaEff/MiniORM/PrimaryKey.java new file mode 100644 index 0000000..5133b48 --- /dev/null +++ b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/MiniORM/src/ru/fizteh/fivt/students/JenkaEff/MiniORM/PrimaryKey.java @@ -0,0 +1,8 @@ +package ru.fizteh.fivt.students.JenkaEff.MiniORM; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +@Retention(RetentionPolicy.RUNTIME) +public @interface PrimaryKey { +} \ No newline at end of file diff --git a/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/MiniORM/src/ru/fizteh/fivt/students/JenkaEff/MiniORM/Table.java b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/MiniORM/src/ru/fizteh/fivt/students/JenkaEff/MiniORM/Table.java new file mode 100644 index 0000000..f31e02b --- /dev/null +++ b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/MiniORM/src/ru/fizteh/fivt/students/JenkaEff/MiniORM/Table.java @@ -0,0 +1,9 @@ +package ru.fizteh.fivt.students.JenkaEff.MiniORM; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +@Retention(RetentionPolicy.RUNTIME) +public @interface Table { + String name() default ""; +} \ No newline at end of file diff --git a/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/reverse/Main.java b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/reverse/Main.java new file mode 100644 index 0000000..59e3aa7 --- /dev/null +++ b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/reverse/Main.java @@ -0,0 +1,12 @@ +package projects.JenkaEff.src.main.java.ru.mipt.diht.students.JenkaEff.reverse; + +public class Main { + public static void main(String[] args) { + String allNumbers = String.join(" ", args).trim(); + String[] numbers = allNumbers.split("\\s+"); + for (int i = numbers.length - 1; i >= 0; i--) { + System.out.print(numbers[i] + " "); + } + System.out.println(); + } +} diff --git a/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/threads/MTQueue.java b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/threads/MTQueue.java new file mode 100644 index 0000000..5181b1e --- /dev/null +++ b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/threads/MTQueue.java @@ -0,0 +1,60 @@ +package projects.JenkaEff.src.main.java.ru.mipt.diht.students.JenkaEff.threads; + +import java.util.ArrayList; +import java.util.Queue; +import java.util.concurrent.ArrayBlockingQueue; +import java.util.concurrent.locks.ReentrantLock; + +class BlockingQueue { + private Queue queue; + private int capacity, size; + private static ReentrantLock lock; + + BlockingQueue(int cap) { + queue = new ArrayBlockingQueue<>(cap); + lock = new ReentrantLock(); + capacity = cap; + size = 0; + } + + protected void putOne(T t) { + lock.lock(); + if (size < capacity) { + queue.offer(t); + size++; + lock.unlock(); + } + } + + public void offer(Iterable e) { + for (T i : e) { + putOne(i); + } + } + + protected T takeOne() { + lock.lock(); + T res = null; + if (size < 0) { + res = queue.poll(); + size--; + lock.unlock(); + } + return res; + } + + public ArrayList take(int n) { + ArrayList res = new ArrayList<>(); + while (n > 0) { + n--; + res.add(takeOne()); + } + return res; + } + +} + +public class MTQueue { + public static void main(String[] args) { + } +} diff --git a/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/threads/Threads1.java b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/threads/Threads1.java new file mode 100644 index 0000000..082e208 --- /dev/null +++ b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/threads/Threads1.java @@ -0,0 +1,49 @@ +package projects.JenkaEff.src.main.java.ru.mipt.diht.students.JenkaEff.threads; + +public class Threads1 { + + private static int THREADS_NUM = 5; + + private static Object[] cvs = new Integer[THREADS_NUM]; + + static class Child implements Runnable { + + private int number; + private int nextNumber; + + Child(int num) { + number = num; + nextNumber = (number + 1) % THREADS_NUM; + } + + @Override + public void run() { + while (true) { + synchronized (cvs[number]) { + try { + cvs[number].wait(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + System.out.println("Thread-" + number); + synchronized (cvs[nextNumber]) { + cvs[nextNumber].notify(); + } + } + } + } + + } + + public static void main(String[] args) throws InterruptedException { + Thread[] threads = new Thread[THREADS_NUM]; + for (int i = 0; i < THREADS_NUM; i++) { + cvs[i] = new Integer(0); + threads[i] = new Thread(new Child(i)); + threads[i].start(); + } + synchronized (cvs[0]) { + cvs[0].notify(); + } + } +} diff --git a/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/threads/Threads2.java b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/threads/Threads2.java new file mode 100644 index 0000000..175ef71 --- /dev/null +++ b/projects/JenkaEff/src/main/java/ru/mipt/diht/students/JenkaEff/threads/Threads2.java @@ -0,0 +1,87 @@ +package projects.JenkaEff.src.main.java.ru.mipt.diht.students.JenkaEff.threads; + +import java.util.Random; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; + +public class Threads2 { + + private static int THREADS_NUM = 10; + private final static double PROB = 0.9; + private final static String NEGATIVE_RESPONSE = "No"; + private final static String POSITIVE_RESPONSE = "Yes"; + + private static Lock[] mutexes = new ReentrantLock[THREADS_NUM]; + private static boolean[] responses = new boolean[THREADS_NUM]; + private static Object cv = new Integer(0); + + static class Child implements Runnable { + + private int number; + private Random rand; + + Child(int num) { + number = num; + rand = new Random(); + } + + private boolean getRandom(double prob) { + return rand.nextDouble() > prob; + } + + @Override + public void run() { + while (true) { + synchronized (cv) { + + try { + cv.wait(); + } catch (InterruptedException e) { + break; + } + mutexes[number].lock(); + try { + responses[number] = getRandom(PROB); + if (responses[number]) { + System.out.println(POSITIVE_RESPONSE + number); + } else { + System.out.println(NEGATIVE_RESPONSE + number); + } + } finally { + mutexes[number].unlock(); + } + } + + } + } + + } + + public static void main(String[] args) throws InterruptedException { + Thread[] threads = new Thread[THREADS_NUM]; + for (int i = 0; i < THREADS_NUM; i++) { + threads[i] = new Thread(new Child(i)); + threads[i].start(); + mutexes[i] = new ReentrantLock(); + } + while (true) { + synchronized (cv) { + + cv.notifyAll(); + boolean flag = true; + for (int i = 0; i < THREADS_NUM; i++) { + mutexes[i].lock(); + flag = flag && responses[i]; + mutexes[i].unlock(); + } + if (flag) { + break; + } + } + } + for (int i = 0; i < THREADS_NUM; i++) { + threads[i].interrupt(); + } + } + +} diff --git a/projects/JenkaEff/src/test/java/ru/mipt/diht/students/AppTest.java b/projects/JenkaEff/src/test/java/ru/mipt/diht/students/AppTest.java new file mode 100644 index 0000000..4bb8dd4 --- /dev/null +++ b/projects/JenkaEff/src/test/java/ru/mipt/diht/students/AppTest.java @@ -0,0 +1,38 @@ +package ru.mipt.diht.students; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +/** + * Unit test for simple App. + */ +public class AppTest + extends TestCase +{ + /** + * Create the test case + * + * @param testName name of the test case + */ + public AppTest( String testName ) + { + super( testName ); + } + + /** + * @return the suite of tests being tested + */ + public static Test suite() + { + return new TestSuite( AppTest.class ); + } + + /** + * Rigourous Test :-) + */ + public void testApp() + { + assertTrue( true ); + } +} diff --git a/projects/pom.xml b/projects/pom.xml index 5d14966..9840366 100644 --- a/projects/pom.xml +++ b/projects/pom.xml @@ -1,5 +1,5 @@ - + + 4.0.0 ru.mipt.diht.students @@ -30,7 +30,8 @@ dkhurtin ale3otik Pitovsky - + JenkaEff + @@ -133,4 +134,4 @@ - + \ No newline at end of file