Coverage Report

Coverage Report - org.kuali.db.jdbc.JDBCUtils

Classes in this File

Line Coverage

Branch Coverage

Complexity

JDBCUtils

0/70

0/32

3.167

 package org.kuali.db.jdbc;
 
 import static org.apache.commons.lang.StringUtils.isNotEmpty;
 import static org.kuali.db.jdbc.DatabaseType.POSTGRESQL;
 
 import java.sql.Connection;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
 import java.util.List;
 
 import org.apache.commons.lang.Validate;
 
 /**
  * Various JDBC related utility methods
  */
 public class JDBCUtils {
 
     List<JDBCConfiguration> jdbcConfigs;
 
     /**
      * Given a database type, return the corresponding JDBC configuration
      *
      * @return JDBCConfiguration
      */
 
     public JDBCConfiguration getDatabaseConfiguration(final DatabaseType type) {
         for (JDBCConfiguration jdbcConfig : jdbcConfigs) {
             if (jdbcConfig.getType().equals(type)) {
                 return jdbcConfig;
             }
         }
         return JDBCConfiguration.UNKNOWN_CONFIG;
     }
 
     /**
      * Given a JDBC url, attempt to locate the corresponding JDBCConfig object
      *
      * @param url
      * @return JDBCConfiguration
      */
     public JDBCConfiguration getDatabaseConfiguration(final String url) {
         Validate.isTrue(isNotEmpty(url));
 
         for (JDBCConfiguration jdbcConfig : jdbcConfigs) {
             String urlFragment = jdbcConfig.getUrlFragment();
             if (url.contains(urlFragment)) {
                 return jdbcConfig;
             }
         }
         return JDBCConfiguration.UNKNOWN_CONFIG;
     }
 
     /**
      * Given a JDBC connection URL, extract only the database name.
      *
      * @param url
      * a JDBC connection URL
      * @return the database name
      */
     public String getDatabaseName(final String url) {
         int leftIndex = url.lastIndexOf("/");
         if (leftIndex == -1) {
             leftIndex = url.lastIndexOf(":");
         }
         leftIndex++;
 
         int rightIndex = url.length();
         if (url.indexOf("?") != -1) {
             rightIndex = url.indexOf("?");
         } else if (url.indexOf(";") != -1) {
             rightIndex = url.indexOf(";");
         }
 
         return url.substring(leftIndex, rightIndex);
     }
 
     /**
      * Given a JDBC connection URL, generate a new connection URL to connect directly to the database server itself (ie:
      * no database specified).
      *
      * @param url
      * a JDBC connection URL
      * @return a new JDBC connection URL to connect directly to the database server
      */
     public String getServerUrl(final String url) {
         int rightIndex = url.length();
         if (url.lastIndexOf("/") != -1) {
             rightIndex = url.lastIndexOf("/");
         } else if (url.lastIndexOf(":") != -1) {
             rightIndex = url.lastIndexOf(":");
         }
 
         String baseUrl = url.substring(0, rightIndex);
 
         // TODO This next line is nasty, but it works for nearly every postgresql server.
         // If we have to add another exception to this for another database server, then I highly recommend refactoring
         // this to a more elegant solution.
         if (POSTGRESQL.equals(getDatabaseConfiguration(url).getType())) {
             baseUrl += "/postgres";
         }
 
         String options = "";
         int optionsIndex = url.indexOf("?");
         if (optionsIndex == -1) {
             optionsIndex = url.indexOf(";");
         }
         if (optionsIndex != -1) {
             options = url.substring(optionsIndex);
         }
 
         return baseUrl + options;
     }
 
     public static void closeQuietly(final ResultSet rs, final Statement stmt, final Connection conn) {
         closeQuietly(rs);
         closeQuietly(stmt);
         closeQuietly(conn);
     }
 
     public static void closeQuietly(final Statement stmt, final Connection conn) {
         closeQuietly(null, stmt, conn);
     }
 
     public static void closeQuietly(final ResultSet rs) {
         if (rs == null) {
             return;
         }
         try {
             rs.close();
         } catch (SQLException e) {
             // ignore
         }
     }
 
     public static void closeQuietly(final Statement stmt) {
         if (stmt == null) {
             return;
         }
         try {
             stmt.close();
         } catch (SQLException e) {
             // ignore
         }
     }
 
     public static void closeQuietly(final Connection conn) {
         if (conn == null) {
             return;
         }
         try {
             conn.close();
         } catch (SQLException e) {
             // ignore
         }
     }
 
     public static void rollbackQuietly(final Connection conn) {
         if (conn == null) {
             return;
         }
         try {
             conn.rollback();
         } catch (SQLException e) {
             // ignore
         }
     }
 
     /**
      * @return the jdbcConfigs
      */
     public List<JDBCConfiguration> getJdbcConfigs() {
         return jdbcConfigs;
     }
 
     /**
      * @param jdbcConfigs
      * the jdbcConfigs to set
      */
     public void setJdbcConfigs(final List<JDBCConfiguration> jdbcConfigs) {
         this.jdbcConfigs = jdbcConfigs;
     }
 
 }

1		package org.kuali.db.jdbc;
2
3		import static org.apache.commons.lang.StringUtils.isNotEmpty;
4		import static org.kuali.db.jdbc.DatabaseType.POSTGRESQL;
5
6		import java.sql.Connection;
7		import java.sql.ResultSet;
8		import java.sql.SQLException;
9		import java.sql.Statement;
10		import java.util.List;
11
12		import org.apache.commons.lang.Validate;
13
14		/**
15		* Various JDBC related utility methods
16		*/
17	0	public class JDBCUtils {
18
19		List<JDBCConfiguration> jdbcConfigs;
20
21		/**
22		* Given a database type, return the corresponding JDBC configuration
23		*
24		* @return JDBCConfiguration
25		*/
26
27		public JDBCConfiguration getDatabaseConfiguration(final DatabaseType type) {
28	0	for (JDBCConfiguration jdbcConfig : jdbcConfigs) {
29	0	if (jdbcConfig.getType().equals(type)) {
30	0	return jdbcConfig;
31		}
32		}
33	0	return JDBCConfiguration.UNKNOWN_CONFIG;
34		}
35
36		/**
37		* Given a JDBC url, attempt to locate the corresponding JDBCConfig object
38		*
39		* @param url
40		* @return JDBCConfiguration
41		*/
42		public JDBCConfiguration getDatabaseConfiguration(final String url) {
43	0	Validate.isTrue(isNotEmpty(url));
44
45	0	for (JDBCConfiguration jdbcConfig : jdbcConfigs) {
46	0	String urlFragment = jdbcConfig.getUrlFragment();
47	0	if (url.contains(urlFragment)) {
48	0	return jdbcConfig;
49		}
50	0	}
51	0	return JDBCConfiguration.UNKNOWN_CONFIG;
52		}
53
54		/**
55		* Given a JDBC connection URL, extract only the database name.
56		*
57		* @param url
58		* a JDBC connection URL
59		* @return the database name
60		*/
61		public String getDatabaseName(final String url) {
62	0	int leftIndex = url.lastIndexOf("/");
63	0	if (leftIndex == -1) {
64	0	leftIndex = url.lastIndexOf(":");
65		}
66	0	leftIndex++;
67
68	0	int rightIndex = url.length();
69	0	if (url.indexOf("?") != -1) {
70	0	rightIndex = url.indexOf("?");
71	0	} else if (url.indexOf(";") != -1) {
72	0	rightIndex = url.indexOf(";");
73		}
74
75	0	return url.substring(leftIndex, rightIndex);
76		}
77
78		/**
79		* Given a JDBC connection URL, generate a new connection URL to connect directly to the database server itself (ie:
80		* no database specified).
81		*
82		* @param url
83		* a JDBC connection URL
84		* @return a new JDBC connection URL to connect directly to the database server
85		*/
86		public String getServerUrl(final String url) {
87	0	int rightIndex = url.length();
88	0	if (url.lastIndexOf("/") != -1) {
89	0	rightIndex = url.lastIndexOf("/");
90	0	} else if (url.lastIndexOf(":") != -1) {
91	0	rightIndex = url.lastIndexOf(":");
92		}
93
94	0	String baseUrl = url.substring(0, rightIndex);
95
96		// TODO This next line is nasty, but it works for nearly every postgresql server.
97		// If we have to add another exception to this for another database server, then I highly recommend refactoring
98		// this to a more elegant solution.
99	0	if (POSTGRESQL.equals(getDatabaseConfiguration(url).getType())) {
100	0	baseUrl += "/postgres";
101		}
102
103	0	String options = "";
104	0	int optionsIndex = url.indexOf("?");
105	0	if (optionsIndex == -1) {
106	0	optionsIndex = url.indexOf(";");
107		}
108	0	if (optionsIndex != -1) {
109	0	options = url.substring(optionsIndex);
110		}
111
112	0	return baseUrl + options;
113		}
114
115		public static void closeQuietly(final ResultSet rs, final Statement stmt, final Connection conn) {
116	0	closeQuietly(rs);
117	0	closeQuietly(stmt);
118	0	closeQuietly(conn);
119	0	}
120
121		public static void closeQuietly(final Statement stmt, final Connection conn) {
122	0	closeQuietly(null, stmt, conn);
123	0	}
124
125		public static void closeQuietly(final ResultSet rs) {
126	0	if (rs == null) {
127	0	return;
128		}
129		try {
130	0	rs.close();
131	0	} catch (SQLException e) {
132		// ignore
133	0	}
134	0	}
135
136		public static void closeQuietly(final Statement stmt) {
137	0	if (stmt == null) {
138	0	return;
139		}
140		try {
141	0	stmt.close();
142	0	} catch (SQLException e) {
143		// ignore
144	0	}
145	0	}
146
147		public static void closeQuietly(final Connection conn) {
148	0	if (conn == null) {
149	0	return;
150		}
151		try {
152	0	conn.close();
153	0	} catch (SQLException e) {
154		// ignore
155	0	}
156	0	}
157
158		public static void rollbackQuietly(final Connection conn) {
159	0	if (conn == null) {
160	0	return;
161		}
162		try {
163	0	conn.rollback();
164	0	} catch (SQLException e) {
165		// ignore
166	0	}
167	0	}
168
169		/**
170		* @return the jdbcConfigs
171		*/
172		public List<JDBCConfiguration> getJdbcConfigs() {
173	0	return jdbcConfigs;
174		}
175
176		/**
177		* @param jdbcConfigs
178		* the jdbcConfigs to set
179		*/
180		public void setJdbcConfigs(final List<JDBCConfiguration> jdbcConfigs) {
181	0	this.jdbcConfigs = jdbcConfigs;
182	0	}
183
184		}