From 351fee60e134bec0d4e1019acad4c9bb3259952b Mon Sep 17 00:00:00 2001
From: AnkitCLI <ankit.yadav@cloudsufi.com>
Date: Mon, 5 Jun 2023 15:20:10 +0530
Subject: [PATCH] commit changes

---
 .../cloudsqlpostgresql/BQValidation.java      |  34 +--
 .../CloudSqlPostgreSqlClient.java             | 236 +++++++++---------
 .../stepsdesign/CloudSqlPostgreSql.java       |   2 +-
 .../resources/pluginParameters.properties     |  17 +-
 4 files changed, 141 insertions(+), 148 deletions(-)

diff --git a/cloudsql-postgresql-plugin/src/e2e-test/java/io/cdap/plugin/cloudsqlpostgresql/BQValidation.java b/cloudsql-postgresql-plugin/src/e2e-test/java/io/cdap/plugin/cloudsqlpostgresql/BQValidation.java
index 86214b9bc..18520a84b 100644
--- a/cloudsql-postgresql-plugin/src/e2e-test/java/io/cdap/plugin/cloudsqlpostgresql/BQValidation.java
+++ b/cloudsql-postgresql-plugin/src/e2e-test/java/io/cdap/plugin/cloudsqlpostgresql/BQValidation.java
@@ -28,6 +28,7 @@
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 import java.sql.*;
+import java.text.SimpleDateFormat;
 import java.time.*;
 import java.util.Date;
 import java.text.ParseException;
@@ -40,51 +41,52 @@
 public class BQValidation {
     static List<JsonObject> BigQueryResponse = new ArrayList<>();
     static List<Object> bigQueryRows = new ArrayList<>();
+    static JsonObject json;
 
     /**
      * Extracts entire data from source and target tables.
-     *
      * @param sourceTable table at the source side
      * @param targetTable table at the sink side
      * @return true if the values in source and target side are equal
      */
     public static boolean validateDBToBQRecordValues(String schema, String sourceTable, String targetTable)
-            throws SQLException, ClassNotFoundException, IOException, InterruptedException {
+            throws SQLException, ClassNotFoundException, IOException, InterruptedException, ParseException {
         getBigQueryTableData(targetTable, bigQueryRows);
         for (Object rows : bigQueryRows) {
-            JsonObject json = new Gson().fromJson(String.valueOf(rows), JsonObject.class);
+            json = new Gson().fromJson(String.valueOf(rows), JsonObject.class);
             BigQueryResponse.add(json);
         }
         String getSourceQuery = "SELECT * FROM " + schema + "." + sourceTable;
-        try (Connection connect = CloudSqlPostgreSqlClient.getCloudSqlConnection()) {
-            connect.setHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT);
-            Statement statement1 = connect.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE,
+        try (Connection connection = CloudSqlPostgreSqlClient.getCloudSqlConnection()) {
+            connection.setHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT);
+            Statement statement1 = connection.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE,
                     ResultSet.HOLD_CURSORS_OVER_COMMIT);
 
             ResultSet rsSource = statement1.executeQuery(getSourceQuery);
             return compareResultSetandJsonData(rsSource, BigQueryResponse);
         }
     }
+
     public static boolean validateBQToDBRecordValues(String schema, String sourceTable, String targetTable)
-            throws SQLException, ClassNotFoundException, IOException, InterruptedException {
+            throws SQLException, ClassNotFoundException, IOException, InterruptedException, ParseException {
         getBigQueryTableData(sourceTable, bigQueryRows);
         for (Object rows : bigQueryRows) {
-            JsonObject json = new Gson().fromJson(String.valueOf(rows), JsonObject.class);
+            json = new Gson().fromJson(String.valueOf(rows), JsonObject.class);
             BigQueryResponse.add(json);
         }
         String getTargetQuery = "SELECT * FROM " + schema + "." + targetTable;
-        try (Connection connect = CloudSqlPostgreSqlClient.getCloudSqlConnection()) {
-            connect.setHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT);
-            Statement statement1 = connect.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE,
+        try (Connection connection = CloudSqlPostgreSqlClient.getCloudSqlConnection()) {
+            connection.setHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT);
+            Statement statement1 = connection.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE,
                     ResultSet.HOLD_CURSORS_OVER_COMMIT);
 
             ResultSet rsTarget = statement1.executeQuery(getTargetQuery);
             return compareResultSetandJsonData(rsTarget, BigQueryResponse);
         }
     }
+
     /**
      * Retrieves the data from a specified BigQuery table and populates it into the provided list of objects.
-     *
      * @param table        The name of the BigQuery table to fetch data from.
      * @param bigQueryRows The list to store the fetched BigQuery data.
      */
@@ -100,7 +102,6 @@ private static void getBigQueryTableData(String table, List<Object> bigQueryRows
 
     /**
      * Compares the data in the result set obtained from the Oracle database with the provided BigQuery JSON objects.
-     *
      * @param rsSource     The result set obtained from the Oracle database.
      * @param bigQueryData The list of BigQuery JSON objects to compare with the result set data.
      * @return True if the result set data matches the BigQuery data, false otherwise.
@@ -108,7 +109,7 @@ private static void getBigQueryTableData(String table, List<Object> bigQueryRows
      * @throws ParseException If an error occurs while parsing the data.
      */
     public static boolean compareResultSetandJsonData(ResultSet rsSource, List<JsonObject> bigQueryData)
-            throws SQLException {
+            throws SQLException, ParseException {
         ResultSetMetaData mdSource = rsSource.getMetaData();
         boolean result = false;
         int columnCountSource = mdSource.getColumnCount();
@@ -161,6 +162,11 @@ public static boolean compareResultSetandJsonData(ResultSet rsSource, List<JsonO
                         break;
 
                     case Types.TIMESTAMP:
+                        Timestamp sourceTS = rsSource.getTimestamp(columnName);
+                        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
+                        Date parsedDate = dateFormat.parse(bigQueryData.get(jsonObjectIdx).get(columnName).getAsString());
+                        Timestamp targetTs = new Timestamp(parsedDate.getTime());
+                        Assert.assertEquals(sourceTS, targetTs);
                         break;
 
                     case Types.TIME:
diff --git a/cloudsql-postgresql-plugin/src/e2e-test/java/io/cdap/plugin/cloudsqlpostgresql/CloudSqlPostgreSqlClient.java b/cloudsql-postgresql-plugin/src/e2e-test/java/io/cdap/plugin/cloudsqlpostgresql/CloudSqlPostgreSqlClient.java
index 69412d43c..da914a1f9 100644
--- a/cloudsql-postgresql-plugin/src/e2e-test/java/io/cdap/plugin/cloudsqlpostgresql/CloudSqlPostgreSqlClient.java
+++ b/cloudsql-postgresql-plugin/src/e2e-test/java/io/cdap/plugin/cloudsqlpostgresql/CloudSqlPostgreSqlClient.java
@@ -32,143 +32,139 @@
 import java.util.TimeZone;
 
 /**
- *  CloudSQLPostgreSQL client.
+ * CloudSQLPostgreSQL client.
  */
 
 public class CloudSqlPostgreSqlClient {
-   public static Connection getCloudSqlConnection() throws ClassNotFoundException, SQLException {
-    Class.forName("org.postgresql.Driver");
-    String database=PluginPropertyUtils.pluginProp("databaseName");
-    String instanceConnectionName = System.getenv("CONNECTION_NAME");
-    String username = System.getenv("CLOUDSQL_POSTGRESQL_USERNAME");
-    String password = System.getenv("CLOUDSQL_POSTGRESQL_PASSWORD");
-
-    String jdbcUrl = String.format(
-      "jdbc:postgresql://google/%s?cloudSqlInstance=%s&socketFactory=com.google.cloud.sql.postgres.SocketFactory&user=%s&password=%s",
-       database,instanceConnectionName, username, password);
-    Connection conn = DriverManager.getConnection(jdbcUrl);
-    System.out.println("Connected to the database successfully");
-    return conn;
-  }
+    public static Connection getCloudSqlConnection() throws ClassNotFoundException, SQLException {
+        Class.forName("org.postgresql.Driver");
+        String database = PluginPropertyUtils.pluginProp("databaseName");
+        String instanceConnectionName = System.getenv("CLOUDSQL_POSTGRESQL_CONNECTION_NAME");
+        String username = System.getenv("CLOUDSQL_POSTGRESQL_USERNAME");
+        String password = System.getenv("CLOUDSQL_POSTGRESQL_PASSWORD");
+        String jdbcUrl = String.format(PluginPropertyUtils.pluginProp("URL"), database, instanceConnectionName, username, password);
+        Connection connection = DriverManager.getConnection(jdbcUrl);
+        return connection;
+    }
 
-  public static int countRecord(String table, String schema) throws SQLException, ClassNotFoundException {
-    String countQuery = "SELECT COUNT(*) as total FROM " + schema + "." + table;
-    try (Connection connect = getCloudSqlConnection();
-         Statement statement = connect.createStatement();
-         ResultSet rs = statement.executeQuery(countQuery)) {
-      int num = 0;
-      while (rs.next()) {
-        num = (rs.getInt(1));
-      }
-      return num;
+    public static int countRecord(String table, String schema) throws SQLException, ClassNotFoundException {
+        String countQuery = "SELECT COUNT(*) as total FROM " + schema + "." + table;
+        try (Connection connection = getCloudSqlConnection();
+             Statement statement = connection.createStatement();
+             ResultSet rs = statement.executeQuery(countQuery)) {
+            int num = 0;
+            while (rs.next()) {
+                num = (rs.getInt(1));
+            }
+            return num;
+        }
     }
-  }
 
-  /**
-   * Extracts entire data from source and target tables.
-   * @param sourceTable table at the source side
-   * @param targetTable table at the sink side
-   * @return true if the values in source and target side are equal
-   */
-  public static boolean validateRecordValues(String sourceTable, String targetTable, String schema)
-    throws SQLException, ClassNotFoundException {
-    String getSourceQuery = "SELECT * FROM " + schema + "." + sourceTable;
-    String getTargetQuery = "SELECT * FROM " + schema + "." + targetTable;
-    try (Connection connect = getCloudSqlConnection()) {
-      connect.setHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT);
-      Statement statement1 = connect.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE,
-                                                     ResultSet.HOLD_CURSORS_OVER_COMMIT);
-      Statement statement2 = connect.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE,
-                                                     ResultSet.HOLD_CURSORS_OVER_COMMIT);
-      ResultSet rsSource = statement1.executeQuery(getSourceQuery);
-      ResultSet rsTarget = statement2.executeQuery(getTargetQuery);
-      return compareResultSetData(rsSource, rsTarget);
+    /**
+     * Extracts entire data from source and target tables.
+     * @param sourceTable table at the source side
+     * @param targetTable table at the sink side
+     * @return true if the values in source and target side are equal
+     */
+    public static boolean validateRecordValues(String sourceTable, String targetTable, String schema)
+            throws SQLException, ClassNotFoundException {
+        String getSourceQuery = "SELECT * FROM " + schema + "." + sourceTable;
+        String getTargetQuery = "SELECT * FROM " + schema + "." + targetTable;
+        try (Connection connection = getCloudSqlConnection()) {
+            connection.setHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT);
+            Statement statement1 = connection.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE,
+                    ResultSet.HOLD_CURSORS_OVER_COMMIT);
+            Statement statement2 = connection.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE,
+                    ResultSet.HOLD_CURSORS_OVER_COMMIT);
+            ResultSet rsSource = statement1.executeQuery(getSourceQuery);
+            ResultSet rsTarget = statement2.executeQuery(getTargetQuery);
+            return compareResultSetData(rsSource, rsTarget);
+        }
     }
-  }
 
-  /**
-   * Compares the result Set data in source table and sink table..
-   * @param rsSource result set of the source table data
-   * @param rsTarget result set of the target table data
-   * @return true if rsSource matches rsTarget
-   */
-  public static boolean compareResultSetData(ResultSet rsSource, ResultSet rsTarget) throws SQLException {
-    ResultSetMetaData mdSource = rsSource.getMetaData();
-    ResultSetMetaData mdTarget = rsTarget.getMetaData();
-    int columnCountSource = mdSource.getColumnCount();
-    int columnCountTarget = mdTarget.getColumnCount();
-    Assert.assertEquals("Number of columns in source and target are not equal",
-                        columnCountSource, columnCountTarget);
-    while (rsSource.next() && rsTarget.next()) {
-      int currentColumnCount = 1;
-      while (currentColumnCount <= columnCountSource) {
-        String columnTypeName = mdSource.getColumnTypeName(currentColumnCount);
-        int columnType = mdSource.getColumnType(currentColumnCount);
-        String columnName = mdSource.getColumnName(currentColumnCount);
-        if (columnType == Types.TIMESTAMP) {
-          GregorianCalendar gc = new GregorianCalendar(TimeZone.getTimeZone("UTC"));
-          gc.setGregorianChange(new Date(Long.MIN_VALUE));
-          Timestamp sourceTS = rsSource.getTimestamp(currentColumnCount, gc);
-          Timestamp targetTS = rsTarget.getTimestamp(currentColumnCount, gc);
-          Assert.assertEquals(String.format("Different values found for column : %s", columnName), sourceTS, targetTS);
-        } else {
-          String sourceString = rsSource.getString(currentColumnCount);
-          String targetString = rsTarget.getString(currentColumnCount);
-          Assert.assertEquals(String.format("Different values found for column : %s", columnName),
-                              sourceString, targetString);
+    /**
+     * Compares the result Set data in source table and sink table..
+     * @param rsSource result set of the source table data
+     * @param rsTarget result set of the target table data
+     * @return true if rsSource matches rsTarget
+     */
+    public static boolean compareResultSetData(ResultSet rsSource, ResultSet rsTarget) throws SQLException {
+        ResultSetMetaData mdSource = rsSource.getMetaData();
+        ResultSetMetaData mdTarget = rsTarget.getMetaData();
+        int columnCountSource = mdSource.getColumnCount();
+        int columnCountTarget = mdTarget.getColumnCount();
+        Assert.assertEquals("Number of columns in source and target are not equal",
+                columnCountSource, columnCountTarget);
+        while (rsSource.next() && rsTarget.next()) {
+            int currentColumnCount = 1;
+            while (currentColumnCount <= columnCountSource) {
+                String columnTypeName = mdSource.getColumnTypeName(currentColumnCount);
+                int columnType = mdSource.getColumnType(currentColumnCount);
+                String columnName = mdSource.getColumnName(currentColumnCount);
+                if (columnType == Types.TIMESTAMP) {
+                    GregorianCalendar gc = new GregorianCalendar(TimeZone.getTimeZone("UTC"));
+                    gc.setGregorianChange(new Date(Long.MIN_VALUE));
+                    Timestamp sourceTS = rsSource.getTimestamp(currentColumnCount, gc);
+                    Timestamp targetTS = rsTarget.getTimestamp(currentColumnCount, gc);
+                    Assert.assertEquals(String.format("Different values found for column : %s", columnName), sourceTS, targetTS);
+                } else {
+                    String sourceString = rsSource.getString(currentColumnCount);
+                    String targetString = rsTarget.getString(currentColumnCount);
+                    Assert.assertEquals(String.format("Different values found for column : %s", columnName),
+                            sourceString, targetString);
+                }
+                currentColumnCount++;
+            }
         }
-        currentColumnCount++;
-      }
+        Assert.assertFalse("Number of rows in Source table is greater than the number of rows in Target table",
+                rsSource.next());
+        Assert.assertFalse("Number of rows in Target table is greater than the number of rows in Source table",
+                rsTarget.next());
+        return true;
     }
-    Assert.assertFalse("Number of rows in Source table is greater than the number of rows in Target table",
-                       rsSource.next());
-    Assert.assertFalse("Number of rows in Target table is greater than the number of rows in Source table",
-                       rsTarget.next());
-    return true;
-  }
 
-  public static void createSourceTable(String sourceTable, String schema) throws SQLException, ClassNotFoundException {
-    try (Connection connect = getCloudSqlConnection();
-         Statement statement = connect.createStatement()) {
-      String datatypesColumns = PluginPropertyUtils.pluginProp("datatypesColumns");
-      String createSourceTableQuery = "CREATE TABLE " + schema + "." + sourceTable + datatypesColumns;
-      statement.executeUpdate(createSourceTableQuery);
-      System.out.println(createSourceTableQuery);
+    public static void createSourceTable(String sourceTable, String schema) throws SQLException, ClassNotFoundException {
+        try (Connection connection = getCloudSqlConnection();
+             Statement statement = connection.createStatement()) {
+            String datatypesColumns = PluginPropertyUtils.pluginProp("datatypesColumns");
+            String createSourceTableQuery = "CREATE TABLE " + schema + "." + sourceTable + datatypesColumns;
+            statement.executeUpdate(createSourceTableQuery);
+            System.out.println(createSourceTableQuery);
 
-      // Insert dummy data.
-      String datatypesValues = PluginPropertyUtils.pluginProp("datatypesValues");
-      String datatypesColumnsList = PluginPropertyUtils.pluginProp("datatypesColumnsList");
-      statement.executeUpdate("INSERT INTO " + schema + "." + sourceTable + " " + datatypesColumnsList + " " +
-                                datatypesValues);
+            // Insert dummy data.
+            String datatypesValues = PluginPropertyUtils.pluginProp("datatypesValues");
+            String datatypesColumnsList = PluginPropertyUtils.pluginProp("datatypesColumnsList");
+            statement.executeUpdate("INSERT INTO " + schema + "." + sourceTable + " " + datatypesColumnsList + " " +
+                    datatypesValues);
+        }
     }
-  }
 
-  public static void createTargetTable(String targetTable, String schema) throws SQLException, ClassNotFoundException {
-    try (Connection connect = getCloudSqlConnection();
-         Statement statement = connect.createStatement()) {
-      String datatypesColumns = PluginPropertyUtils.pluginProp("datatypesColumns");
-      String createTargetTableQuery = "CREATE TABLE " + schema + "." + targetTable + " " + datatypesColumns;
-      statement.executeUpdate(createTargetTableQuery);
+    public static void createTargetTable(String targetTable, String schema) throws SQLException, ClassNotFoundException {
+        try (Connection connection = getCloudSqlConnection();
+             Statement statement = connection.createStatement()) {
+            String datatypesColumns = PluginPropertyUtils.pluginProp("datatypesColumns");
+            String createTargetTableQuery = "CREATE TABLE " + schema + "." + targetTable + " " + datatypesColumns;
+            statement.executeUpdate(createTargetTableQuery);
+        }
     }
-  }
 
-  public static void createTargetPostgresqlTable(String targetTable, String schema) throws SQLException,
-    ClassNotFoundException {
-    try (Connection connect = getCloudSqlConnection();
-         Statement statement = connect.createStatement()) {
-      String datatypesColumns = PluginPropertyUtils.pluginProp("bigQueryDatatypesColumns");
-      String createTargetTableQuery = "CREATE TABLE " + schema + "." + targetTable + " " + datatypesColumns;
-      statement.executeUpdate(createTargetTableQuery);
+    public static void createTargetPostgresqlTable(String targetTable, String schema) throws SQLException,
+            ClassNotFoundException {
+        try (Connection connection = getCloudSqlConnection();
+             Statement statement = connection.createStatement()) {
+            String datatypesColumns = PluginPropertyUtils.pluginProp("bigQueryDatatypesColumns");
+            String createTargetTableQuery = "CREATE TABLE " + schema + "." + targetTable + " " + datatypesColumns;
+            statement.executeUpdate(createTargetTableQuery);
+        }
     }
-  }
 
-  public static void dropTables(String[] tables, String schema) throws SQLException, ClassNotFoundException {
-    try (Connection connect = getCloudSqlConnection();
-         Statement statement = connect.createStatement()) {
-      for (String table : tables) {
-        String dropTableQuery = "Drop Table " + schema + "." + table;
-        statement.executeUpdate(dropTableQuery);
-      }
+    public static void dropTables(String[] tables, String schema) throws SQLException, ClassNotFoundException {
+        try (Connection connection = getCloudSqlConnection();
+             Statement statement = connection.createStatement()) {
+            for (String table : tables) {
+                String dropTableQuery = "Drop Table " + schema + "." + table;
+                statement.executeUpdate(dropTableQuery);
+            }
+        }
     }
-  }
 }
diff --git a/cloudsql-postgresql-plugin/src/e2e-test/java/io/cdap/plugin/cloudsqlpostgresql/stepsdesign/CloudSqlPostgreSql.java b/cloudsql-postgresql-plugin/src/e2e-test/java/io/cdap/plugin/cloudsqlpostgresql/stepsdesign/CloudSqlPostgreSql.java
index 041cdb47d..216083aa3 100644
--- a/cloudsql-postgresql-plugin/src/e2e-test/java/io/cdap/plugin/cloudsqlpostgresql/stepsdesign/CloudSqlPostgreSql.java
+++ b/cloudsql-postgresql-plugin/src/e2e-test/java/io/cdap/plugin/cloudsqlpostgresql/stepsdesign/CloudSqlPostgreSql.java
@@ -15,7 +15,7 @@
 import java.text.ParseException;
 
 /**
- *  CLOUDSQLPOSTGRESQL Plugin related step design.
+ *  CLOUDSQL POSTGRESQL Step design.
  */
 public class CloudSqlPostgreSql implements CdfHelper {
 
diff --git a/cloudsql-postgresql-plugin/src/e2e-test/resources/pluginParameters.properties b/cloudsql-postgresql-plugin/src/e2e-test/resources/pluginParameters.properties
index fb415f9a7..f0ffadb0d 100644
--- a/cloudsql-postgresql-plugin/src/e2e-test/resources/pluginParameters.properties
+++ b/cloudsql-postgresql-plugin/src/e2e-test/resources/pluginParameters.properties
@@ -3,7 +3,7 @@ username=CLOUDSQL_POSTGRESQL_USERNAME
 password=CLOUDSQL_POSTGRESQL_PASSWORD
 databaseName=test_automation_db
 schema=public
-
+URL=jdbc:postgresql://google/%s?cloudSqlInstance=%s&socketFactory=com.google.cloud.sql.postgres.SocketFactory&user=%s&password=%s
 datatypesColumns=( id varchar(100) primary key, col1 bpchar, col2 bpchar(10), col3 varchar, col4 varchar(3), \
   col5 bytea, col6 int2, col7 int4, col8 int8, col10 numeric(10, 4), col11 numeric(10), col12 float4, col13 float8, \
   col14 money, col15 text, col16 name, col17 float8, col18 numeric(38), col22 timestamp, col23 timestamptz, \
@@ -13,13 +13,11 @@ datatypesColumns=( id varchar(100) primary key, col1 bpchar, col2 bpchar(10), co
   col47 tsvector, col48 txid_snapshot, col49 uuid, col50 xml, col51 int4range, col52 int8range, col53 numrange, \
   col54 tsrange, col55 tstzrange, col56 daterange, col57 pg_lsn, col58 int4, col59 int2, col60 int8, col61 real, \
   col62 smallint, col63 serial, col64 smallserial, col65 double precision, col66 bigint, col67 bigserial, col68 boolean)
-
 datatypesColumnsList=( id, col1, col2, col3, col4, col5, col6 , col7 , col8 , col10, col11, col12, col13, col14, \
   col15, col16, col17, col18, col22, col23, col24, col25, col26, col27, col28, col29, col30, col31, col32, col33, \
   col34, col35, col36, col37, col38, col39, col40, col41, col42, col43, col44, col45, col46, col47, col48, col49, \
   col50, col51, col52, col53, col54, col55, col56, col57, col58, col59, col60, col61, col62, col63, col64, col65,\
   col66, col67, col68 )
-
 datatypesValues=VALUES ('User5', 'M', 'ABC...1234', 'B', 'ABC', decode('48656C6C6F20576F726C6421','hex'), 123, 123, \
   123456, 123.4567, 123456789, 123.456, 123.456, 100.26, 'Hello World!', 'User 5', 123.456, 100, \
   '2023-01-01 07:30:00.000', '2023-01-01 15:30:00.000', '02:00:00', '6 mons 02:30:00'::interval, \
@@ -35,7 +33,6 @@ datatypesValues=VALUES ('User5', 'M', 'ABC...1234', 'B', 'ABC', decode('48656C6C
   '["2010-01-01 20:00:00+05:30","2010-01-01 21:00:00+05:30")'::tstzrange, '[1992-03-21,1994-06-26)'::daterange, \
   '16/B374D848'::pg_lsn, 2, 2, 2, '1234.5679', '600', DEFAULT, DEFAULT, '61.823765812', '2500000000000', \
   DEFAULT, false);
-
 datatypesSchema=[{"key":"id","value":"string"},{"key":"col1","value":"string"},{"key":"col2","value":"string"},\
   {"key":"col3","value":"string"},{"key":"col4","value":"string"},{"key":"col5","value":"bytes"},\
   {"key":"col6","value":"int"},{"key":"col7","value":"int"},{"key":"col8","value":"long"},\
@@ -58,7 +55,6 @@ datatypesSchema=[{"key":"id","value":"string"},{"key":"col1","value":"string"},{
   {"key":"col61","value":"float"},{"key":"col62","value":"int"},{"key":"col63","value":"int"},\
   {"key":"col64","value":"int"},{"key":"col65","value":"double"},{"key":"col66","value":"long"},\
   {"key":"col67","value":"long"},{"key":"col68","value":"boolean"}]
-
 #CLOUDSQLPOSTGRESQL Invalid Properties
 invalidRef=invalidRef&^*&&*
 invalidDatabaseName=invalidDB
@@ -71,32 +67,27 @@ invalidBoundingQuery=SELECT MIN(id),MAX(id) FROM table
 invalidBoundingQueryValue=select;
 invalidTable=table
 invalidConnectionName=abd3
-
 #CLOUDSQLPOSTGRESQL Valid Properties
 connectionArgumentsList=[{"key":"queryTimeout","value":"-1"}]
 connectionTimeout=150
 numberOfSplits=2
 zeroValue=0
 splitByColumn=ID
-importQuery =  where $CONDITIONS
-connectionName=CONNECTION_NAME
-
+importQuery=where $CONDITIONS
+connectionName=CLOUDSQL_POSTGRESQL_CONNECTION_NAME
 #bq properties
 projectId=cdf-athena
 dataset=test_automation
-bqOutputMultipleDatatypesSchema= [{"key":"col1","value":"bytes"},{"key":"col2","value":"string"},\
+bqOutputMultipleDatatypesSchema=[{"key":"col1","value":"bytes"},{"key":"col2","value":"string"},\
   {"key":"col3","value":"date"},{"key":"col4","value":"double"},{"key":"col5","value":"decimal"},\
   {"key":"col6","value":"timestamp"},{"key":"col7","value":"decimal"},{"key":"col8","value":"boolean"},\
   {"key":"col9","value":"long"},{"key":"col10","value":"time"}]
-
 #bq macro properties
 bqTruncateTable=true
 bqUpdateTableSchema=true
-
 #bq queries file path
 CreateBQTableQueryFile=testdata/BigQuery/BigQueryCreateTableQuery.txt
 InsertBQDataQueryFile=testdata/BigQuery/BigQueryInsertDataQuery.txt
-
 #BIGQUERY Datatypes
 bigQueryDatatypesColumns=(col1 bytea, col2 varchar(100), col3 date, col4 double precision, col5 numeric(5, 2), \
   col6 timestamp, col7 numeric(5, 2), col8 boolean, col9 int8, col10 time)