Active record pattern

active-record/etc/active-record.urm.puml

@@ -0,0 +1,40 @@
+@startuml
+package com.iluwatar.activeobject {
+  class ActiveDatabase {
+    ~ dbDomain : String
+    ~ dbName : String
+    ~ password : String
+    ~ tableName : String
+    ~ username : String
+    + ActiveDatabase(dbName : String, username : String, password : String, dbDomain : String, tableName : String)
+    + getDbDomain() : String
+    + getDbName() : String
+    + getPassword() : String
+    + getTableName() : String
+    + getUsername() : String
+  }
+  class ActiveRow {
+    ~ columnCount : int
+    ~ columns : ArrayList<String>
+    ~ con : Connection
+    ~ contents : ArrayList<String>
+    ~ dataBase : ActiveDatabase
+    ~ delete : String
+    ~ id : String
+    ~ read : String
+    ~ write : String
+    + ActiveRow(dataBase : ActiveDatabase, id : String)
+    + delete()
+    + initialise()
+    + read() : ArrayList<String>
+    + write()
+  }
+  class App {
+    + App()
+    + main(args : String[]) {static}
+  }
+  interface Rowverride {
+  }
+}
+ActiveRow -->  "-dataBase" ActiveDatabase
+@enduml

active-record/pom.xml

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <artifactId>java-design-patterns</artifactId>
+        <groupId>com.iluwatar</groupId>
+        <version>1.26.0-SNAPSHOT</version>
+    </parent>
+    <artifactId>active-record</artifactId>
+    <dependencies>
+        <dependency>
+            <groupId>com.mysql</groupId>
+            <artifactId>mysql-connector-j</artifactId>
+            <version>8.0.31</version>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+    <properties>
+        <maven.compiler.source>15</maven.compiler.source>
+        <maven.compiler.target>15</maven.compiler.target>
+    </properties>
+
+    <build>
+        <plugins>
+            <!-- Maven assembly plugin is invoked with default setting which we have
+                      in parent pom and specifying the class having main method -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-assembly-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <configuration>
+                            <archive>
+                                <manifest>
+                                    <mainClass>active-record</mainClass>
+                                </manifest>
+                            </archive>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

active-record/src/main/java/com/iluwatar/activeobject/ActiveDatabase.java

@@ -0,0 +1,55 @@
+package com.iluwatar.activeobject;
+
+import java.sql.SQLException;
+
+/**
+ * This class initialises frequently needed variables for the MySQLWorkbench Database.
+ */
+public class ActiveDatabase {
+
+  final String dbDomain;
+  final String dbName;
+  final String username;
+  final String password;
+  final String tableName;
+
+  /**
+   * Constructor needed to instantiate the database object which is used with the MySQLWorkbench
+   * Database.
+   *
+   * @param dbName    Name of the database as String.
+   * @param username  Username for the database as String.
+   * @param password  Password for the database as String.
+   * @param dbDomain  The domain for the database as String. Tested on localhost:3306
+   * @param tableName Name of the table which you wish to create the active row.
+   */
+  public ActiveDatabase(String dbName, String username, String password, String dbDomain,
+      String tableName) {
+    this.dbDomain = dbDomain;
+    this.dbName = dbName;
+    this.username = username;
+    this.password = password;
+    this.tableName = tableName;
+  }
+
+  public String getDbDomain() {
+    return dbDomain;
+  }
+
+  public String getDbName() {
+    return dbName;
+  }
+
+  public String getUsername() {
+    return username;
+  }
+
+  public String getPassword() {
+    return password;
+  }
+
+  public String getTableName() {
+    return tableName;
+  }
+
+}

active-record/src/main/java/com/iluwatar/activeobject/ActiveRow.java

@@ -0,0 +1,159 @@
+package com.iluwatar.activeobject;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+
+/**
+ * ActiveRow attempts to implement the fundamental ruby on rails 'Active Record' design pattern in
+ * Java.
+ */
+public class ActiveRow {
+
+  String id;
+  ActiveDatabase dataBase;
+  Connection con;
+  String read;
+  String delete;
+  String write;
+  int columnCount;
+  ArrayList<String> columns;
+  ArrayList<String> contents = new ArrayList<>();
+
+  /**
+   * ActiveRow attempts to implement the fundamental ruby on rails 'Active Record' design pattern in
+   * Java.
+   *
+   * @param dataBase A Database object which handles opening the connection.
+   * @param id       The unique identifier of a row.
+   */
+  public ActiveRow(ActiveDatabase dataBase, String id) {
+    this.dataBase = dataBase;
+    this.id = id;
+    initialise();
+  }
+
+  /**
+   * This initialises the class by creating a connection and populating the column names and other
+   * variables which are used in the program.
+   */
+  @Rowverride
+  public void initialise() {
+    try {
+      con = DriverManager
+          .getConnection("jdbc:mysql://" + dataBase.getDbDomain() + "/" + dataBase.getDbName(),
+              dataBase.getUsername(), dataBase.getPassword());
+    } catch (SQLException e) {
+      e.printStackTrace();
+    }
+
+    try {
+      Statement statement = con.createStatement();
+      ResultSet columnSet = statement.executeQuery(
+          "SELECT * FROM `" + dataBase.getDbName() + "`.`" + dataBase.getTableName() + "`");
+      ArrayList<String> columnNames = new ArrayList<String>();
+      ResultSetMetaData rsmd = columnSet.getMetaData();
+      columnCount = rsmd.getColumnCount();
+      for (int i = 1; i < columnCount + 1; i++) {
+        String name = rsmd.getColumnName(i);
+        columnNames.add(name);
+      }
+      this.columns = columnNames;
+      read =
+          "SELECT * FROM `" + dataBase.getDbName() + "`.`" + dataBase.getTableName() + "` WHERE ID="
+              + this.id;
+      delete = "DELETE FROM `" + dataBase.getDbName() + "`.`" + dataBase.getTableName() + "`"
+          + " WHERE ID = '" + this.id + "';";
+      write = "INSERT INTO `" + dataBase.getDbName() + "`.`" + dataBase.getTableName() + "`";
+      statement.close();
+      columnSet.close();
+    } catch (SQLException e) {
+      e.printStackTrace();
+    }
+
+
+  }
+
+  /**
+   * Writes contents of the active row object to the chosen database.
+   */
+  @Rowverride
+  public void write() {
+    StringBuilder query = new StringBuilder();
+    query.append(write);
+    query.append(" VALUES (");
+    for (String con : this.contents) {
+      if (contents.indexOf(con) != this.contents.size() - 1) {
+        query.append("'");
+        query.append(con);
+        query.append("' ");
+        query.append(",");
+      } else {
+        query.append("'");
+        query.append(con);
+        query.append("' ");
+        query.append(")");
+      }
+    }
+
+    try {
+      PreparedStatement stmt = con.prepareStatement(query.toString());
+      stmt.executeUpdate();
+
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+
+  }
+
+  /**
+   * Deletes the current instance of the active row from the database based on the given ID value.
+   */
+  @Rowverride
+  public void delete() {
+    if (this.read().equals(new ArrayList<String>())) {
+      System.out.println("Row does not exist.");
+      return;
+    }
+    try {
+      con.prepareStatement(delete).executeUpdate();
+
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
+
+  /**
+   * Reads the current active row.
+   *
+   * @return the current active row contents as Arraylist
+   */
+  @Rowverride
+  public ArrayList<String> read() {
+    try {
+      Statement statement = con.createStatement();
+
+      ResultSet rowResult = statement.executeQuery(read);
+      while (rowResult.next()) {
+        for (int col = 1; col <= columnCount; col++) {
+          Object value = rowResult.getObject(col);
+          if (value != null) {
+            contents.add(value.toString());
+          }
+        }
+      }
+      rowResult.close();
+
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+
+    return this.contents;
+  }
+
+}

active-record/src/main/java/com/iluwatar/activeobject/App.java

@@ -0,0 +1,30 @@
+package com.iluwatar.activeobject;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * Useful examples of common useage of the program.
+ */
+public class App {
+
+  /**
+   * Use this method to become familiar with the program.
+   *
+   * @param args arguments passed into the main method.
+   */
+  public static void main(String[] args) {
+    try {
+      ActiveDatabase activeDatabase = new ActiveDatabase("world", "root", "apple-trunks", "localhost:3306", "city");
+      ActiveRow ar = new ActiveRow(activeDatabase, "101");
+      ar.contents = new ArrayList<String>(
+          Arrays.asList("101", "Godoy Cruz", "ARG", "Mendoza", "206998"));
+      ar.write();
+      System.out.println(ar.read());
+
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+
+  }
+}

active-record/src/main/java/com/iluwatar/activeobject/Rowverride.java

@@ -0,0 +1,12 @@
+package com.iluwatar.activeobject;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.SOURCE)
+public @interface Rowverride {
+
+}