());
53 | }
54 |
55 | @After("execution(* org.springframework.batch.core.launch.JobLauncher.run(..)) &&" +
56 | " args(job, jobParameters)")
57 | public void printStatistic(Job job, JobParameters jobParameters) {
58 | String schemaName = jobParameters.getString("schemaName");
59 | prettyPrint(schemaName);
60 |
61 | }
62 |
63 | /**
64 | * report something like this:
65 | *
66 | * -------------------------------------------------------
67 | * R E P O R T S K I P P E D O B J E C T S
68 | * -------------------------------------------------------
69 | * | skip rule | object type | count |
70 | * -------------------------------------------------------
71 | * | config | INDEX | 2 |
72 | * | sql error | PUBLIC DATABASE LINK | 4 |
73 | *
74 | *
75 | * @param schemaName
76 | * @param listExludedByConfig
77 | * @param listSkippedBySQLError
78 | */
79 | public void prettyPrint(String schemaName) {
80 | String lSep = System.getProperty("line.separator");
81 | StringBuilder sb = new StringBuilder();
82 | sb.append(lSep);
83 | sb.append("-------------------------------------------------------");
84 | sb.append(lSep);
85 | sb.append(" R E P O R T S K I P P E D O B J E C T S ");
86 | sb.append(lSep);
87 | sb.append("-------------------------------------------------------");
88 |
89 | if (listExludedByConfig.size() + listSkippedBySQLError.size() == 0) {
90 | sb.append(" No skipped objects ");
91 | sb.append(lSep);
92 | return;
93 | }
94 |
95 | sb.append(lSep);
96 | sb.append("| skip rule | object type | count |");
97 | sb.append(lSep);
98 | sb.append("-------------------------------------------------------");
99 | sb.append(lSep);
100 |
101 | prettyPrintList(sb, " config ", listExludedByConfig);
102 | prettyPrintList(sb, "sql error", listSkippedBySQLError);
103 |
104 | System.out.println(sb.toString());
105 |
106 | }
107 |
108 | private void prettyPrintList(StringBuilder sb, String ruleName, List listExludedByConfig) {
109 | String lSep = System.getProperty("line.separator");
110 | Map groupByType = groupByType(listExludedByConfig);
111 | for (String type : groupByType.keySet()) {
112 | Formatter formatter = new Formatter();
113 | sb.append(formatter.format("| %s | %-24s | %-6s |", ruleName, type, groupByType.get(type)).toString());
114 | sb.append(lSep);
115 | }
116 | }
117 |
118 | private Map groupByType(List list) {
119 | Map map = new HashMap();
120 | for (UserObject userObject : list) {
121 |
122 | if (map.containsKey(userObject.getType())) {
123 | map.put(userObject.getType(), map.get(userObject.getType()) + 1);
124 | } else {
125 | map.put(userObject.getType(), 1);
126 | }
127 | }
128 | return map;
129 | }
130 |
131 | }
132 |
--------------------------------------------------------------------------------
/src/main/java/com/googlecode/scheme2ddl/db2/dao/ConnectionDao.java:
--------------------------------------------------------------------------------
1 | package com.googlecode.scheme2ddl.db2.dao;
2 |
3 | import org.springframework.stereotype.Component;
4 |
5 | import java.util.List;
6 |
7 | /**
8 | * Check some properties of connection
9 | *
10 | * @author A_Reshetnikov
11 | * @since Date: 23.07.2013
12 | */
13 | public interface ConnectionDao {
14 |
15 | boolean isConnectionAvailable();
16 |
17 | List findAvailableSchemas();
18 | }
19 |
--------------------------------------------------------------------------------
/src/main/java/com/googlecode/scheme2ddl/db2/dao/ConnectionDaoImpl.java:
--------------------------------------------------------------------------------
1 | package com.googlecode.scheme2ddl.db2.dao;
2 |
3 | import org.springframework.beans.factory.annotation.Autowired;
4 | import org.springframework.dao.DataAccessException;
5 | import org.springframework.jdbc.core.support.JdbcDaoSupport;
6 | import org.springframework.stereotype.Component;
7 |
8 | import javax.sql.DataSource;
9 | import java.util.List;
10 |
11 | /**
12 | * @author A_Reshetnikov
13 | * @since Date: 23.07.2013
14 | */
15 | @Component(value = "connectionDao")
16 | public class ConnectionDaoImpl extends JdbcDaoSupport implements ConnectionDao {
17 |
18 | @Autowired
19 | public ConnectionDaoImpl(DataSource dataSource) {
20 | this.setDataSource(dataSource);
21 | }
22 |
23 | public boolean isConnectionAvailable() {
24 | try {
25 | getJdbcTemplate().queryForInt("select 1 from SYSIBM.dual");
26 | } catch (DataAccessException e) {
27 | return false;
28 | }
29 | return true;
30 | }
31 |
32 | public List findAvailableSchemas() {
33 | return getJdbcTemplate().queryForList("SELECT table_schem from SYSIBM.SQLSCHEMAS ", String.class );
34 | }
35 |
36 |
37 | }
38 |
--------------------------------------------------------------------------------
/src/main/java/com/googlecode/scheme2ddl/db2/dao/GrantsDao.java:
--------------------------------------------------------------------------------
1 | package com.googlecode.scheme2ddl.db2.dao;
2 |
3 | import com.googlecode.scheme2ddl.db2.domain.RoutineAuth;
4 | import com.googlecode.scheme2ddl.db2.domain.TabAuth;
5 | import com.googlecode.scheme2ddl.db2.domain.UserObject;
6 |
7 | import java.util.List;
8 |
9 | /**
10 | * @author ar
11 | * @since Date: 14.12.2014
12 | */
13 | public interface GrantsDao {
14 |
15 | List findTableGrants(UserObject userObject);
16 |
17 | List findRoutineGrants(UserObject userObject);
18 | }
19 |
--------------------------------------------------------------------------------
/src/main/java/com/googlecode/scheme2ddl/db2/dao/GrantsDaoImpl.java:
--------------------------------------------------------------------------------
1 | package com.googlecode.scheme2ddl.db2.dao;
2 |
3 | import com.googlecode.scheme2ddl.db2.domain.*;
4 | import org.springframework.beans.factory.annotation.Autowired;
5 | import org.springframework.context.annotation.Scope;
6 | import org.springframework.jdbc.core.RowMapper;
7 | import org.springframework.jdbc.core.support.JdbcDaoSupport;
8 | import org.springframework.stereotype.Component;
9 |
10 | import javax.sql.DataSource;
11 | import java.sql.ResultSet;
12 | import java.sql.SQLException;
13 | import java.util.List;
14 |
15 | /**
16 | * @author ar
17 | * @since Date: 14.12.2014
18 | */
19 | @Component(value = "grantsDao")
20 | @Scope(value = "step")
21 | public class GrantsDaoImpl extends JdbcDaoSupport implements GrantsDao {
22 |
23 |
24 | @Autowired
25 | public GrantsDaoImpl(DataSource dataSource) {
26 | setDataSource(dataSource);
27 | }
28 |
29 | public List findTableGrants(UserObject userObject) {
30 |
31 |
32 | return getJdbcTemplate().query("select * from SYSCAT.TABAUTH where TABSCHEMA = ? and GRANTOR != 'SYSIBM' and TABNAME = ?",
33 | new Object[]{userObject.getSchema(), userObject.getName()},
34 | new RowMapper() {
35 | public TabAuth mapRow(ResultSet rs, int rowNum) throws SQLException {
36 | TabAuth tabAuth = new TabAuth();
37 | tabAuth.setGrantee(rs.getString("GRANTEE"));
38 | tabAuth.setGranteeType(GranteeType.mapByCode(rs.getString("GRANTEETYPE")));
39 | tabAuth.setTabSchema(rs.getString("TABSCHEMA"));
40 | tabAuth.setTabName(rs.getString("TABNAME"));
41 | tabAuth.setAlterAuth(GrantType.valueOf(rs.getString("ALTERAUTH")));
42 | tabAuth.setControlAuth(GrantType.valueOf(rs.getString("CONTROLAUTH")));
43 | tabAuth.setDeleteAuth(GrantType.valueOf(rs.getString("DELETEAUTH")));
44 | tabAuth.setIndexAuth(GrantType.valueOf(rs.getString("INDEXAUTH")));
45 | tabAuth.setInsertAuth(GrantType.valueOf(rs.getString("INSERTAUTH")));
46 | tabAuth.setRefAuth(GrantType.valueOf(rs.getString("REFAUTH")));
47 | tabAuth.setSelectAuth(GrantType.valueOf(rs.getString("SELECTAUTH")));
48 | tabAuth.setUpdateAuth(GrantType.valueOf(rs.getString("UPDATEAUTH")));
49 |
50 | if ("PUBLIC ".equals(tabAuth.getGrantee())) {
51 | tabAuth.setGranteeType(GranteeType.PUBLIC);
52 | }
53 | return tabAuth;
54 | }
55 | });
56 | }
57 |
58 | public List findRoutineGrants(UserObject userObject) {
59 | return getJdbcTemplate().query("select * from SYSCAT.ROUTINEAUTH where SCHEMA = ? and GRANTOR != 'SYSIBM' and SPECIFICNAME = ?",
60 | new Object[]{userObject.getSchema(), userObject.getName()},
61 | new RowMapper() {
62 | public RoutineAuth mapRow(ResultSet rs, int rowNum) throws SQLException {
63 | RoutineAuth routineAuth = new RoutineAuth();
64 | routineAuth.setGrantee(rs.getString("GRANTEE"));
65 | routineAuth.setGranteeType(GranteeType.mapByCode(rs.getString("GRANTEETYPE")));
66 | routineAuth.setSchema(rs.getString("SCHEMA"));
67 | routineAuth.setSpecificname(rs.getString("SPECIFICNAME"));
68 | routineAuth.setRoutineType(RoutineAuth.RoutineType.mapByCode(rs.getString("ROUTINETYPE")));
69 | routineAuth.setExecuteAuth(GrantType.valueOf(rs.getString("EXECUTEAUTH")));
70 |
71 | if (GranteeType.GROUP.equals(routineAuth.getGranteeType())
72 | && "PUBLIC ".equals(routineAuth.getGrantee())){
73 | routineAuth.setGranteeType(GranteeType.PUBLIC);
74 | }
75 |
76 | return routineAuth;
77 | }
78 | });
79 | }
80 | }
81 |
--------------------------------------------------------------------------------
/src/main/java/com/googlecode/scheme2ddl/db2/dao/UserObjectDao.java:
--------------------------------------------------------------------------------
1 | package com.googlecode.scheme2ddl.db2.dao;
2 |
3 | import com.googlecode.scheme2ddl.db2.domain.Db2LookInfo;
4 | import com.googlecode.scheme2ddl.db2.domain.UserObject;
5 |
6 | import java.util.List;
7 |
8 | /**
9 | * @author A_Reshetnikov
10 | * @since Date: 17.10.2012
11 | */
12 | public interface UserObjectDao {
13 |
14 | List findListForProccessing();
15 |
16 | List findDDLs(UserObject userObject);
17 |
18 | List findTableColumns(UserObject userObject);
19 |
20 | List findTableIndexes(UserObject userObject);
21 |
22 | List findTableChecks(UserObject userObject);
23 |
24 | List findTableFkeys(UserObject userObject);
25 |
26 | List findTablePkeys(UserObject userObject);
27 |
28 | List findTableUniques(UserObject userObject);
29 |
30 | void callCleanTable(Long opToken);
31 |
32 |
33 | }
34 |
--------------------------------------------------------------------------------
/src/main/java/com/googlecode/scheme2ddl/db2/dao/UserObjectDaoDb2Impl.java:
--------------------------------------------------------------------------------
1 | package com.googlecode.scheme2ddl.db2.dao;
2 |
3 | import com.googlecode.scheme2ddl.db2.domain.DB2ObjectType;
4 | import com.googlecode.scheme2ddl.db2.domain.Db2LookInfo;
5 | import com.googlecode.scheme2ddl.db2.domain.UserObject;
6 | import org.apache.commons.logging.Log;
7 | import org.apache.commons.logging.LogFactory;
8 | import org.springframework.beans.factory.annotation.Autowired;
9 | import org.springframework.beans.factory.annotation.Value;
10 | import org.springframework.context.annotation.Scope;
11 | import org.springframework.jdbc.core.RowMapper;
12 | import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
13 | import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
14 | import org.springframework.jdbc.core.support.JdbcDaoSupport;
15 | import org.springframework.stereotype.Component;
16 |
17 | import javax.annotation.PostConstruct;
18 | import javax.annotation.Resource;
19 | import javax.sql.DataSource;
20 | import java.sql.*;
21 | import java.util.HashSet;
22 | import java.util.List;
23 | import java.util.Map;
24 | import java.util.Set;
25 |
26 | /**
27 | * @author A_Reshetnikov
28 | * @since Date: 17.10.2012
29 | */
30 | @Component(value = "userObjectDao")
31 | @Scope(value = "step")
32 | public class UserObjectDaoDb2Impl extends JdbcDaoSupport implements UserObjectDao {
33 |
34 | private static final Log log = LogFactory.getLog(UserObjectDaoDb2Impl.class);
35 | @Value("#{jobParameters['schemaName']}")
36 | private String schemaName;
37 |
38 | private Set nonPrimaryTypes;
39 |
40 | @Resource(name = "dependencies")
41 | private Map> dependencies;
42 |
43 |
44 | @Autowired
45 | public UserObjectDaoDb2Impl(DataSource dataSource) {
46 | setDataSource(dataSource);
47 |
48 | }
49 |
50 | @PostConstruct
51 | public void setNonPrimaryTypesFromDependencies() {
52 | nonPrimaryTypes = new HashSet();
53 | for (DB2ObjectType key : dependencies.keySet()) {
54 | for (DB2ObjectType depended : dependencies.get(key)) {
55 | nonPrimaryTypes.add(depended.getInternalName());
56 | }
57 | }
58 | }
59 |
60 | public List findListForProccessing() {
61 |
62 |
63 | long opToken = call_DB2LK_GENERATE_DDL("-e -z " + schemaName);
64 |
65 | log.debug("findListForProccessing opToken is " + opToken);
66 |
67 | MapSqlParameterSource parameters = new MapSqlParameterSource();
68 | parameters.addValue("opToken", opToken);
69 | parameters.addValue("schemaName", schemaName);
70 |
71 |
72 | NamedParameterJdbcTemplate namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(getJdbcTemplate());
73 |
74 | String sql = "SELECT DISTINCT OBJ_TYPE, OBJ_NAME, OP_TOKEN " +
75 | "FROM SYSTOOLS.DB2LOOK_INFO WHERE OP_TOKEN=:opToken AND OBJ_SCHEMA=:schemaName " ;
76 | if (nonPrimaryTypes != null && !nonPrimaryTypes.isEmpty()) {
77 | parameters.addValue("nonPrimaryTypes", nonPrimaryTypes);
78 | sql += " and OBJ_TYPE not in (:nonPrimaryTypes) ";
79 | }
80 |
81 | return namedParameterJdbcTemplate.query(sql, parameters, new UserObjectRowMapper());
82 | }
83 |
84 |
85 | private long call_DB2LK_GENERATE_DDL(String db2lookinfoParams) { //todo rename
86 | long opToken = 0;
87 | Connection con = null;
88 | //todo rewrite with spring
89 |
90 | try {
91 | con = getDataSource().getConnection();
92 | CallableStatement cstmt;
93 | ResultSet rs;
94 | cstmt = con.prepareCall("CALL SYSPROC.DB2LK_GENERATE_DDL(?, ?)");
95 | cstmt.setString(1, db2lookinfoParams);
96 | cstmt.registerOutParameter(2, Types.BIGINT);
97 | cstmt.executeUpdate();
98 | opToken = cstmt.getLong(2);
99 | } catch (SQLException e) {
100 | e.printStackTrace();
101 | } finally {
102 | if (con != null) {
103 | try {
104 | con.close();
105 | } catch (SQLException e) {
106 | e.printStackTrace();
107 | }
108 | }
109 | }
110 | return opToken;
111 |
112 | }
113 |
114 | public List findDDLs(UserObject userObject) {
115 | return getJdbcTemplate().query("select OP_SEQUENCE, SQL_STMT, OBJ_SCHEMA, OBJ_TYPE, OBJ_NAME, SQL_OPERATION " +
116 | "FROM SYSTOOLS.DB2LOOK_INFO where OP_TOKEN=? and OBJ_SCHEMA=? and OBJ_TYPE=? and OBJ_NAME=?",
117 | new Object[]{userObject.getOpToken(), schemaName, userObject.getType(), userObject.getName()},
118 | new Db2LookInfoRowMapper());
119 |
120 | }
121 |
122 | public List findTableColumns(UserObject userObject) {
123 | if (!"TABLE".equals(userObject.getType())) {
124 | throw new IllegalArgumentException();
125 | }
126 |
127 | List list = getJdbcTemplate().query(
128 | "SELECT * " +
129 | " FROM SYSTOOLS.DB2LOOK_INFO t " +
130 | " WHERE OBJ_TYPE = 'COLUMN' " +
131 | " AND OP_TOKEN = ? " +
132 | " and OBJ_SCHEMA=? " +
133 | " and OBJ_NAME like ? " +
134 | " ",
135 | new Object[]{userObject.getOpToken(), schemaName, userObject.getName() + "\".\"%"},
136 | new Db2LookInfoRowMapper());
137 |
138 | return list;
139 | }
140 |
141 | public List findTableIndexes(UserObject userObject) {
142 |
143 | if (!"TABLE".equals(userObject.getType())) {
144 | throw new IllegalArgumentException();
145 | }
146 |
147 | List list = getJdbcTemplate().query(
148 | "SELECT * " +
149 | " FROM SYSTOOLS.DB2LOOK_INFO t " +
150 | " WHERE OBJ_TYPE = 'INDEX' " +
151 | " AND OP_TOKEN = ? " +
152 | " AND exists( " +
153 | " SELECT 1 " +
154 | " FROM SYSCAT.INDEXES i " +
155 | " WHERE TABSCHEMA = ? AND TABNAME = ? AND i.INDNAME = t.OBJ_NAME ) ",
156 | new Object[]{userObject.getOpToken(), schemaName, userObject.getName()},
157 |
158 | new Db2LookInfoRowMapper());
159 |
160 |
161 | return list;
162 | }
163 |
164 | public List findTableFkeys(UserObject userObject) {
165 | List list = getJdbcTemplate().query(
166 | "SELECT * " +
167 | " FROM SYSTOOLS.DB2LOOK_INFO t " +
168 | " WHERE OBJ_TYPE = 'FKEY' " +
169 | " AND OP_TOKEN = ? " +
170 | " and OBJ_SCHEMA=? " +
171 | " and OBJ_NAME=? " +
172 | " ",
173 | new Object[]{userObject.getOpToken(), schemaName, userObject.getName()},
174 |
175 | new Db2LookInfoRowMapper());
176 |
177 |
178 | return list;
179 | }
180 |
181 | public List findTableChecks(UserObject userObject) {
182 | List list = getJdbcTemplate().query(
183 | "SELECT * " +
184 | " FROM SYSTOOLS.DB2LOOK_INFO t " +
185 | " WHERE OBJ_TYPE = 'CHECK' " +
186 | " AND OP_TOKEN = ? " +
187 | " and OBJ_SCHEMA=? " +
188 | " and OBJ_NAME=? " +
189 | " ",
190 | new Object[]{userObject.getOpToken(), schemaName, userObject.getName()},
191 |
192 | new Db2LookInfoRowMapper());
193 |
194 |
195 | return list;
196 | }
197 |
198 | public List findTablePkeys(UserObject userObject) {
199 | List list = getJdbcTemplate().query(
200 | "SELECT * " +
201 | " FROM SYSTOOLS.DB2LOOK_INFO t " +
202 | " WHERE OBJ_TYPE = 'PKEY' AND OP_TOKEN = ? AND t.OBJ_SCHEMA = ? AND OBJ_NAME = ?" ,
203 | new Object[]{userObject.getOpToken(), schemaName, userObject.getName()},
204 |
205 | new Db2LookInfoRowMapper());
206 |
207 |
208 | return list;
209 | }
210 |
211 | public List findTableUniques(UserObject userObject) {
212 | List list = getJdbcTemplate().query(
213 | "SELECT * " +
214 | " FROM SYSTOOLS.DB2LOOK_INFO t " +
215 | " WHERE OBJ_TYPE = 'UNIQUE' AND OP_TOKEN = ? AND t.OBJ_SCHEMA = ? AND OBJ_NAME = ?",
216 | new Object[]{userObject.getOpToken(), schemaName, userObject.getName()},
217 | new Db2LookInfoRowMapper());
218 | return list;
219 | }
220 |
221 | public void callCleanTable(Long opToken) {
222 |
223 | getJdbcTemplate().execute(String.format("call SYSPROC.DB2LK_CLEAN_TABLE(%d)", opToken));
224 | //todo rewrite with ps
225 | }
226 |
227 | public void setSchemaName(String schemaName) {
228 | this.schemaName = schemaName;
229 | }
230 |
231 |
232 | private class UserObjectRowMapper implements RowMapper {
233 | public UserObject mapRow(ResultSet rs, int rowNum) throws SQLException {
234 | UserObject userObject = new UserObject();
235 | userObject.setName(rs.getString("OBJ_NAME"));
236 | userObject.setType(rs.getString("OBJ_TYPE"));
237 | userObject.setOpToken(rs.getLong("OP_TOKEN"));
238 | userObject.setSchema(schemaName == null ? "" : schemaName);
239 | return userObject;
240 | }
241 | }
242 |
243 | private class Db2LookInfoRowMapper implements RowMapper {
244 | public Db2LookInfo mapRow(ResultSet rs, int rowNum) throws SQLException {
245 | Db2LookInfo db2LookInfo = new Db2LookInfo();
246 | db2LookInfo.setObjName(rs.getString("OBJ_NAME"));
247 | db2LookInfo.setObjType(rs.getString("OBJ_TYPE"));
248 | db2LookInfo.setObjSchema(rs.getString("OBJ_SCHEMA").trim());
249 | db2LookInfo.setOpSequence(rs.getLong("OP_SEQUENCE"));
250 | db2LookInfo.setSqlOperation(rs.getString("SQL_OPERATION"));
251 | db2LookInfo.setSqlStmtClob(rs.getClob("SQL_STMT"));
252 |
253 | if (db2LookInfo.getSqlStmtClob() != null) {
254 |
255 | if ((int) db2LookInfo.getSqlStmtClob().length() > 0) {
256 | String s = db2LookInfo.getSqlStmtClob().getSubString(1, (int) db2LookInfo.getSqlStmtClob().length());
257 | db2LookInfo.setSqlStmt(s);
258 | }
259 | }
260 |
261 | return db2LookInfo;
262 | }
263 | }
264 |
265 | }
266 |
--------------------------------------------------------------------------------
/src/main/java/com/googlecode/scheme2ddl/db2/domain/DB2ObjectType.java:
--------------------------------------------------------------------------------
1 | package com.googlecode.scheme2ddl.db2.domain;
2 |
3 | /**
4 | * @author ar
5 | * @since Date: 14.12.2014
6 | */
7 | public enum DB2ObjectType {
8 | ALIAS(null),
9 | CHECK(null),
10 | COLUMN(null),
11 | FOREIGN_KEY("FKEY"),
12 | FUNCTION(null),
13 | MODULE(null),
14 | MQT(null),
15 | INDEX(null),
16 | NICKNAME(null),
17 | PACKAGE(null),
18 | PRIMARY_KEY("PKEY"),
19 | PROCEDURE(null),
20 | REFERENCE(null),
21 | ROUTINE(null), //todo remove
22 | SCHEMA(null),
23 | SEQUENCE(null),
24 | TABLE(null),
25 | TABLESPACE(null),
26 | TRIGGER(null),
27 | UDF(null),
28 | UDT(null),
29 | UNIQUE(null),
30 | VIEW(null),
31 | VARIABLE(null),
32 | XML_SCHEMA(null),
33 |
34 | OBJECT_GRANTS(null);
35 |
36 | private String internalName;
37 |
38 | DB2ObjectType(String internalName) {
39 | this.internalName = internalName;
40 | }
41 |
42 | public String getInternalName() {
43 | return internalName == null ? name() : internalName;
44 | }
45 | }
--------------------------------------------------------------------------------
/src/main/java/com/googlecode/scheme2ddl/db2/domain/Db2LookInfo.java:
--------------------------------------------------------------------------------
1 | package com.googlecode.scheme2ddl.db2.domain;
2 |
3 | import java.sql.Clob;
4 |
5 | /**
6 | * Object to represent some fields of SYSTOOLS.DB2LOOK_INFO table in DB2
7 | * @author ar
8 | * @since Date: 29.11.2014
9 | */
10 | public class Db2LookInfo {
11 |
12 | /*
13 | CREATE TABLE DB2LOOK_INFO
14 | (
15 | OP_TOKEN INT NOT NULL,
16 | OP_SEQUENCE INT NOT NULL,
17 | SQL_OPERATION VARCHAR(129) NOT NULL,
18 | OBJ_ID INT,
19 | OBJ_TYPE VARCHAR(129) NOT NULL,
20 | OBJ_SUBTYPE CHAR(1),
21 | OBJ_SCHEMA VARCHAR(129),
22 | OBJ_NAME VARCHAR(129) NOT NULL,
23 | OBJ_DEFINER VARCHAR(129),
24 | OBJ_QUALIFIER VARCHAR(129),
25 | OBJ_ATTRIBUTE VARCHAR(129),
26 | RELATED_OBJ_INFO VARCHAR(254),
27 | CREATION_TIME TIMESTAMP,
28 | SQL_STMT CLOB(2097152) NOT NULL
29 | );
30 | CREATE UNIQUE INDEX DB2LK_SEQUENCE_IND ON DB2LOOK_INFO (OP_TOKEN, OP_SEQUENCE, CREATION_TIME);
31 | CREATE UNIQUE INDEX DB2LOOK_IND ON DB2LOOK_INFO (OP_TOKEN, SQL_OPERATION, OBJ_TYPE, OBJ_SCHEMA, OBJ_NAME);
32 |
33 | */
34 |
35 | private long opToken;
36 | private long opSequence;
37 | private String objSchema;
38 | private String objName;
39 | private String objType;
40 | private String sqlOperation;
41 | private String sqlStmt;
42 | private Clob sqlStmtClob;
43 |
44 | public long getOpToken() {
45 | return opToken;
46 | }
47 |
48 | public void setOpToken(long opToken) {
49 | this.opToken = opToken;
50 | }
51 |
52 | public long getOpSequence() {
53 | return opSequence;
54 | }
55 |
56 | public void setOpSequence(long opSequence) {
57 | this.opSequence = opSequence;
58 | }
59 |
60 | public String getObjSchema() {
61 | return objSchema;
62 | }
63 |
64 | public void setObjSchema(String objSchema) {
65 | this.objSchema = objSchema;
66 | }
67 |
68 | public String getObjName() {
69 | return objName;
70 | }
71 |
72 | public void setObjName(String objName) {
73 | this.objName = objName;
74 | }
75 |
76 | public String getObjType() {
77 | return objType;
78 | }
79 |
80 | public void setObjType(String objType) {
81 | this.objType = objType;
82 | }
83 |
84 | public String getSqlOperation() {
85 | return sqlOperation;
86 | }
87 |
88 | public void setSqlOperation(String sqlOperation) {
89 | this.sqlOperation = sqlOperation;
90 | }
91 |
92 | public String getSqlStmt() {
93 | return sqlStmt;
94 | }
95 |
96 | public void setSqlStmt(String sqlStmt) {
97 | this.sqlStmt = sqlStmt;
98 | }
99 |
100 | public Clob getSqlStmtClob() {
101 | return sqlStmtClob;
102 | }
103 |
104 | public void setSqlStmtClob(Clob sqlStmtClob) {
105 | this.sqlStmtClob = sqlStmtClob;
106 | }
107 |
108 | @Override
109 | public String toString() {
110 | return "Db2LookInfo{" +
111 | "opToken=" + opToken +
112 | ", opSequence=" + opSequence +
113 | ", objSchema=" + objSchema +
114 | ", objName=" + objName +
115 | ", objType=" + objType +
116 | ", sqlOperation='" + sqlOperation + '\'' +
117 | ", sqlStmt='" + sqlStmt + '\'' +
118 | '}';
119 | }
120 | }
121 |
--------------------------------------------------------------------------------
/src/main/java/com/googlecode/scheme2ddl/db2/domain/GrantType.java:
--------------------------------------------------------------------------------
1 | package com.googlecode.scheme2ddl.db2.domain;
2 |
3 | /**
4 | * @author ar
5 | * @since Date: 01.04.2015
6 | */
7 | public enum GrantType {
8 | G("WITH GRANT OPTION"),
9 | N(""),
10 | Y("");
11 |
12 | private String sql;
13 |
14 | GrantType(String sql) {
15 | this.sql = sql;
16 | }
17 |
18 | public String getSql() {
19 | return sql;
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/src/main/java/com/googlecode/scheme2ddl/db2/domain/GranteeType.java:
--------------------------------------------------------------------------------
1 | package com.googlecode.scheme2ddl.db2.domain;
2 |
3 | import java.util.HashMap;
4 | import java.util.Map;
5 |
6 | /**
7 | * @author ar
8 | * @since Date: 01.04.2015
9 | */
10 | public enum GranteeType {
11 | USER("U", "USER"),
12 | GROUP("G", "GROUP"),
13 | ROlE("R", "ROLE"),
14 | PUBLIC("", "");
15 |
16 | private String code;
17 | private String sql;
18 |
19 | private static Map map;
20 |
21 | static {
22 | map = new HashMap();
23 |
24 | for (GranteeType granteeType : GranteeType.values()) {
25 | map.put(granteeType.getCode(), granteeType);
26 | }
27 | }
28 |
29 |
30 | GranteeType(String code, String sql) {
31 | this.code = code;
32 | this.sql = sql;
33 | }
34 |
35 | public String getCode() {
36 | return code;
37 | }
38 |
39 | public String getSql() {
40 | return sql;
41 | }
42 |
43 | public static GranteeType mapByCode(String code) {
44 | return map.get(code);
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/src/main/java/com/googlecode/scheme2ddl/db2/domain/RoutineAuth.java:
--------------------------------------------------------------------------------
1 | package com.googlecode.scheme2ddl.db2.domain;
2 |
3 | import java.util.HashMap;
4 | import java.util.Map;
5 |
6 | /**
7 | *
8 | * * Content of FROM SYSCAT.TABAUTH
9 | * Authorization Statements on routines
10 | *
11 | * @author ar
12 | * @since Date: 01.04.2015
13 | */
14 | public class RoutineAuth {
15 | /*
16 | CREATE TABLE "ROUTINEAUTH"
17 | (
18 | "GRANTEE" VARCHAR(128) NOT NULL,
19 | "GRANTEETYPE" CHAR(1) NOT NULL,
20 | "SCHEMA" VARCHAR(128) NOT NULL,
21 | "SPECIFICNAME" VARCHAR(128),
22 | "ROUTINETYPE" CHAR(1) NOT NULL,
23 | "EXECUTEAUTH" CHAR(1) NOT NULL,
24 | );
25 |
26 | */
27 |
28 | private String grantee;
29 | private GranteeType granteeType;
30 | private String schema;
31 | private String specificname;
32 | private RoutineType routineType;
33 | private GrantType executeAuth;
34 |
35 |
36 | /**
37 | * @author ar
38 | * @since Date: 01.04.2015
39 | */
40 | public enum RoutineType {
41 | FUNCTION("F"),
42 | METHOD("M"),
43 | PROCEDURE("P");
44 |
45 | private String code;
46 |
47 | private static Map map;
48 |
49 | static {
50 | map = new HashMap();
51 |
52 | for (RoutineType routineType : RoutineType.values()) {
53 | map.put(routineType.getCode(), routineType);
54 | }
55 | }
56 |
57 | RoutineType(String code) {
58 | this.code = code;
59 | }
60 |
61 | public String getCode() {
62 | return code;
63 | }
64 |
65 | public static RoutineType mapByCode(String code) {
66 | return map.get(code);
67 | }
68 | }
69 |
70 | public String getGrantee() {
71 | return grantee;
72 | }
73 |
74 | public void setGrantee(String grantee) {
75 | this.grantee = grantee;
76 | }
77 |
78 | public GranteeType getGranteeType() {
79 | return granteeType;
80 | }
81 |
82 | public void setGranteeType(GranteeType granteeType) {
83 | this.granteeType = granteeType;
84 | }
85 |
86 | public String getSchema() {
87 | return schema;
88 | }
89 |
90 | public void setSchema(String schema) {
91 | this.schema = schema;
92 | }
93 |
94 | public String getSpecificname() {
95 | return specificname;
96 | }
97 |
98 | public void setSpecificname(String specificname) {
99 | this.specificname = specificname;
100 | }
101 |
102 | public RoutineType getRoutineType() {
103 | return routineType;
104 | }
105 |
106 | public void setRoutineType(RoutineType routineType) {
107 | this.routineType = routineType;
108 | }
109 |
110 | public GrantType getExecuteAuth() {
111 | return executeAuth;
112 | }
113 |
114 | public void setExecuteAuth(GrantType executeAuth) {
115 | this.executeAuth = executeAuth;
116 | }
117 | }
118 |
--------------------------------------------------------------------------------
/src/main/java/com/googlecode/scheme2ddl/db2/domain/TabAuth.java:
--------------------------------------------------------------------------------
1 | package com.googlecode.scheme2ddl.db2.domain;
2 |
3 | /**
4 | * Content of FROM SYSCAT.TABAUTH
5 | * Authorization Statements on Tables/Views
6 | *
7 | * @author ar
8 | * @since Date: 14.12.2014
9 | */
10 | public class TabAuth {
11 |
12 | /*
13 | CREATE TABLE TABAUTH
14 | (
15 | GRANTOR VARCHAR(128) NOT NULL,
16 | GRANTORTYPE CHAR(1) NOT NULL,
17 | GRANTEE VARCHAR(128) NOT NULL,
18 | GRANTEETYPE CHAR(1) NOT NULL,
19 | TABSCHEMA VARCHAR(128) NOT NULL,
20 | TABNAME VARCHAR(128) NOT NULL,
21 | CONTROLAUTH CHAR(1) NOT NULL,
22 | ALTERAUTH CHAR(1) NOT NULL,
23 | DELETEAUTH CHAR(1) NOT NULL,
24 | INDEXAUTH CHAR(1) NOT NULL,
25 | INSERTAUTH CHAR(1) NOT NULL,
26 | REFAUTH CHAR(1) NOT NULL,
27 | SELECTAUTH CHAR(1) NOT NULL,
28 | UPDATEAUTH CHAR(1) NOT NULL
29 | );
30 |
31 | */
32 |
33 | private String grantee;
34 | private GranteeType granteeType;
35 | private String tabSchema;
36 | private String tabName;
37 | private GrantType controlAuth;
38 | private GrantType alterAuth;
39 | private GrantType deleteAuth;
40 | private GrantType indexAuth;
41 | private GrantType insertAuth;
42 | private GrantType refAuth;
43 | private GrantType selectAuth;
44 | private GrantType updateAuth;
45 |
46 |
47 | public String getGrantee() {
48 | return grantee;
49 | }
50 |
51 | public void setGrantee(String grantee) {
52 | this.grantee = grantee;
53 | }
54 |
55 | public GranteeType getGranteeType() {
56 | return granteeType;
57 | }
58 |
59 | public void setGranteeType(GranteeType granteeType) {
60 | this.granteeType = granteeType;
61 | }
62 |
63 | public String getTabSchema() {
64 | return tabSchema;
65 | }
66 |
67 | public void setTabSchema(String tabSchema) {
68 | this.tabSchema = tabSchema;
69 | }
70 |
71 | public String getTabName() {
72 | return tabName;
73 | }
74 |
75 | public void setTabName(String tabName) {
76 | this.tabName = tabName;
77 | }
78 |
79 | public GrantType getControlAuth() {
80 | return controlAuth;
81 | }
82 |
83 | public void setControlAuth(GrantType controlAuth) {
84 | this.controlAuth = controlAuth;
85 | }
86 |
87 | public GrantType getAlterAuth() {
88 | return alterAuth;
89 | }
90 |
91 | public void setAlterAuth(GrantType alterAuth) {
92 | this.alterAuth = alterAuth;
93 | }
94 |
95 | public GrantType getDeleteAuth() {
96 | return deleteAuth;
97 | }
98 |
99 | public void setDeleteAuth(GrantType deleteAuth) {
100 | this.deleteAuth = deleteAuth;
101 | }
102 |
103 | public GrantType getIndexAuth() {
104 | return indexAuth;
105 | }
106 |
107 | public void setIndexAuth(GrantType indexAuth) {
108 | this.indexAuth = indexAuth;
109 | }
110 |
111 | public GrantType getInsertAuth() {
112 | return insertAuth;
113 | }
114 |
115 | public void setInsertAuth(GrantType insertAuth) {
116 | this.insertAuth = insertAuth;
117 | }
118 |
119 | public GrantType getRefAuth() {
120 | return refAuth;
121 | }
122 |
123 | public void setRefAuth(GrantType refAuth) {
124 | this.refAuth = refAuth;
125 | }
126 |
127 | public GrantType getSelectAuth() {
128 | return selectAuth;
129 | }
130 |
131 | public void setSelectAuth(GrantType selectAuth) {
132 | this.selectAuth = selectAuth;
133 | }
134 |
135 | public GrantType getUpdateAuth() {
136 | return updateAuth;
137 | }
138 |
139 | public void setUpdateAuth(GrantType updateAuth) {
140 | this.updateAuth = updateAuth;
141 | }
142 |
143 | }
144 |
--------------------------------------------------------------------------------
/src/main/java/com/googlecode/scheme2ddl/db2/domain/UserObject.java:
--------------------------------------------------------------------------------
1 | package com.googlecode.scheme2ddl.db2.domain;
2 |
3 | /**
4 | * @author A_Reshetnikov
5 | * @since Date: 17.10.2012
6 | */
7 | public class UserObject {
8 |
9 | private String name;
10 | private String type;
11 | private String schema;
12 | private String ddl;
13 | private String fileName;
14 | private long opToken;
15 |
16 |
17 | public String getName() {
18 | return name;
19 | }
20 |
21 | public void setName(String name) {
22 | this.name = name;
23 | }
24 |
25 | public String getType() {
26 | return type;
27 | }
28 |
29 | public String getSchema() {
30 | return schema;
31 | }
32 |
33 | public void setType(String type) {
34 | this.type = type;
35 | }
36 |
37 | public void setSchema(String schema) {
38 | this.schema = schema;
39 | }
40 |
41 | public String getDdl() {
42 | return ddl;
43 | }
44 |
45 | public void setDdl(String ddl) {
46 | this.ddl = ddl;
47 | }
48 |
49 | public String getFileName() {
50 | return fileName;
51 | }
52 |
53 | public void setFileName(String fileName) {
54 | this.fileName = fileName;
55 | }
56 |
57 | public long getOpToken() {
58 | return opToken;
59 | }
60 |
61 | public void setOpToken(long opToken) {
62 | this.opToken = opToken;
63 | }
64 |
65 | @Override
66 | public String toString() {
67 | return "UserObject{" +
68 | "name='" + name + '\'' +
69 | ", type='" + type + '\'' +
70 | ", schema='" + schema + '\'' +
71 | ", ddl='" + ddl + '\'' +
72 | '}';
73 | }
74 | }
75 |
--------------------------------------------------------------------------------
/src/main/java/com/googlecode/scheme2ddl/db2/listener/AfterStepListener.java:
--------------------------------------------------------------------------------
1 | package com.googlecode.scheme2ddl.db2.listener;
2 |
3 | import com.googlecode.scheme2ddl.db2.dao.UserObjectDao;
4 | import org.springframework.batch.core.ExitStatus;
5 | import org.springframework.batch.core.StepExecution;
6 | import org.springframework.batch.core.StepExecutionListener;
7 | import org.springframework.beans.factory.annotation.Autowired;
8 | import org.springframework.stereotype.Component;
9 |
10 | /**
11 | * @author ar
12 | * @since Date: 30.05.2015
13 | */
14 | @Component
15 | public class AfterStepListener implements StepExecutionListener {
16 |
17 | @Autowired
18 | private UserObjectDao userObjectDao;
19 |
20 |
21 | public void beforeStep(StepExecution stepExecution) {
22 | //todo implement beforeStep in AfterStepListener
23 | }
24 |
25 | public ExitStatus afterStep(StepExecution stepExecution) {
26 | Long opToken = stepExecution.getExecutionContext().getLong("opToken");
27 | if (opToken != null) {
28 | userObjectDao.callCleanTable(opToken);
29 | }
30 | return stepExecution.getExitStatus();
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/src/main/java/com/googlecode/scheme2ddl/exception/CannotGetDDLException.java:
--------------------------------------------------------------------------------
1 | package com.googlecode.scheme2ddl.exception;
2 |
3 | /**
4 | * @author A_Reshetnikov
5 | * @since Date: 16.05.2013
6 | */
7 | public class CannotGetDDLException extends Exception {
8 |
9 | public CannotGetDDLException() {
10 | super();
11 | }
12 |
13 | public CannotGetDDLException(Throwable cause) {
14 | super(cause);
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/src/main/java/com/googlecode/scheme2ddl/exception/NonSkippableException.java:
--------------------------------------------------------------------------------
1 | package com.googlecode.scheme2ddl.exception;
2 |
3 | /**
4 | * @author A_Reshetnikov
5 | * @since Date: 03.07.2013
6 | */
7 | public class NonSkippableException extends Exception {
8 | public NonSkippableException() {
9 | }
10 |
11 | public NonSkippableException(Throwable cause) {
12 | super(cause);
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/src/main/resources/applicationContext.xml:
--------------------------------------------------------------------------------
1 |
2 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
39 |
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
--------------------------------------------------------------------------------
/src/main/resources/db2-scheme2ddl.config.xml:
--------------------------------------------------------------------------------
1 |
2 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
44 |
45 |
46 |
62 |
63 |
64 |
65 |
67 |
68 |
69 |
70 |
71 |
72 | sql
73 |
74 |
75 |
76 |
77 |
79 |
80 |
81 |
82 | COLUMN
83 | PRIMARY_KEY
84 | FOREIGN_KEY
85 | CHECK
86 | UNIQUE
87 | INDEX
88 | OBJECT_GRANTS
89 |
90 |
91 |
92 |
93 |
94 | OBJECT_GRANTS
95 |
96 |
97 |
98 |
99 | OBJECT_GRANTS
100 |
101 |
102 |
103 |
104 | OBJECT_GRANTS
105 |
106 |
107 |
108 |
109 |
110 |
113 |
114 |
115 |
116 |
117 |
118 |
119 |
120 |
121 |
122 |
123 | SQLJ
124 | SYSCAT
125 | SYSFUN
126 | SYSIBM
127 | SYSIBMADM
128 | SYSIBMINTERNAL
129 | SYSIBMTS
130 | SYSPROC
131 | SYSPUBLIC
132 | SYSSTAT
133 | SQLTRACE
134 | SYSTOOLS
135 |
136 |
137 |
138 |
139 | true
140 | false
141 |
142 |
143 |
144 |
145 |
--------------------------------------------------------------------------------
/src/main/resources/log4j.properties:
--------------------------------------------------------------------------------
1 | log4j.rootCategory=INFO, stdout
2 |
3 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender
4 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
5 | log4j.appender.stdout.layout.ConversionPattern=%m%n
6 |
7 | log4j.category.org.springframework=WARN
8 | #log4j.category.org.springframework.jdbc=TRACE
9 | #log4j.category.org.springframework.batch=TRACE
10 | #log4j.category.com.googlecode.scheme2ddl=TRACE
--------------------------------------------------------------------------------
/src/test/java/com/googlecode/scheme2ddl/db2/FileNameConstructorTest.java:
--------------------------------------------------------------------------------
1 | package com.googlecode.scheme2ddl.db2;
2 |
3 | import com.googlecode.scheme2ddl.db2.domain.UserObject;
4 | import org.junit.Before;
5 | import org.junit.Test;
6 |
7 | import java.util.ArrayList;
8 | import java.util.HashMap;
9 | import java.util.List;
10 | import java.util.Map;
11 |
12 | import static org.junit.Assert.assertEquals;
13 |
14 | /**
15 | * @author A_Reshetnikov
16 | * @since Date: 03.05.2013
17 | */
18 |
19 | public class FileNameConstructorTest {
20 | private FileNameConstructor fileNameConstructor;
21 | private List list;
22 |
23 | @Before
24 | public void setUp() throws Exception {
25 | this.fileNameConstructor = new FileNameConstructor();
26 | fileNameConstructor.afterPropertiesSet();
27 | this.list = new ArrayList();
28 | UserObject userObject = new UserObject();
29 | userObject.setName("SimpleName");
30 | userObject.setType("Table");
31 | userObject.setSchema("SCHEMA_Name");
32 | list.add(userObject);
33 |
34 | userObject = new UserObject();
35 | userObject.setName("SYS$_#NAME");
36 | userObject.setType("REFRESH GROUP");
37 | userObject.setSchema("");
38 | list.add(userObject);
39 |
40 | userObject = new UserObject();
41 | userObject.setName("StraNge_NAME$");
42 | userObject.setType("Index");
43 | userObject.setSchema("dummy");
44 | list.add(userObject);
45 |
46 | userObject = new UserObject();
47 | userObject.setName("lib01");
48 | userObject.setType("library");
49 | userObject.setSchema("dummy");
50 | list.add(userObject);
51 |
52 | userObject = new UserObject();
53 | userObject.setName("TYPE_01");
54 | userObject.setType("TYPE");
55 | userObject.setSchema("TYPES");
56 | list.add(userObject);
57 |
58 | userObject = new UserObject();
59 | userObject.setName("oracle/i18n/data/lx10039.glb");
60 | userObject.setType("JAVA RESOURCE");
61 | userObject.setSchema("SYS");
62 | list.add(userObject);
63 |
64 |
65 | }
66 |
67 | // @org.junit.Test
68 | // public void testMap2FileName() throws Exception {
69 | //
70 | // }
71 |
72 | @Test
73 | public void testDefaultTemplate() throws Exception {
74 | for (UserObject userObject : list) {
75 | String fileName = FileNameConstructor.pluralaze(FileNameConstructor.abbreviate(userObject.getType())).replace(" ", "_") + "/" + userObject.getName() + ".sql";
76 | fileName = fileName.toLowerCase();
77 | assertEquals(fileName, fileNameConstructor.map2FileName(userObject));
78 | }
79 | }
80 |
81 | @Test
82 | public void testKeywordSchema() throws Exception {
83 | String template = FileNameConstructor.kw_schema_lower + "/" + FileNameConstructor.kw_schema_UPPER;
84 | fileNameConstructor.setTemplate(template);
85 | fileNameConstructor.afterPropertiesSet();
86 | for (UserObject userObject : list) {
87 | String fileName = userObject.getSchema().toLowerCase() + "/" + userObject.getSchema().toUpperCase();
88 | assertEquals(fileName, fileNameConstructor.map2FileName(userObject));
89 | }
90 | }
91 |
92 | @Test
93 | public void testKeywordObjectName() throws Exception {
94 | String template = FileNameConstructor.kw_objectname_lower + "/" + FileNameConstructor.kw_objectname_UPPER;
95 | fileNameConstructor.setTemplate(template);
96 | fileNameConstructor.afterPropertiesSet();
97 | for (UserObject userObject : list) {
98 | String fileName = userObject.getName().toLowerCase() + "/" + userObject.getName().toUpperCase();
99 | assertEquals(fileName, fileNameConstructor.map2FileName(userObject));
100 | }
101 | }
102 |
103 | @Test
104 | public void testKeywordExtension() throws Exception {
105 | String template = FileNameConstructor.kw_extension_lower + "/" + FileNameConstructor.kw_extension_UPPER;
106 | fileNameConstructor.setTemplate(template);
107 | fileNameConstructor.afterPropertiesSet();
108 | for (UserObject userObject : list) {
109 | String fileName = "sql" + "/" + "sql".toUpperCase();
110 | assertEquals(fileName, fileNameConstructor.map2FileName(userObject));
111 | }
112 | }
113 |
114 | @Test
115 | public void testTemplateWithTypeMix() throws Exception {
116 | String template = FileNameConstructor.kw_type_lower + "/" + FileNameConstructor.kw_type_lower +
117 | FileNameConstructor.kw_type_UPPER + "/" + FileNameConstructor.kw_types_plural_lower + "//" +
118 | FileNameConstructor.kw_types_plural_UPPER + "/" + FileNameConstructor.kw_types_plural_UPPER + ".TyPEs_PLURAL";
119 | fileNameConstructor.setTemplate(template);
120 | fileNameConstructor.afterPropertiesSet();
121 | for (UserObject userObject : list) {
122 | String type = FileNameConstructor.abbreviate(userObject.getType().toLowerCase()).replace(" ", "_");
123 | String typePlural = FileNameConstructor.pluralaze(FileNameConstructor.abbreviate(userObject.getType())).replace(" ", "_");
124 | String fileName = type.toLowerCase() + "/" + type.toLowerCase() +
125 | type.toUpperCase() + "/" + typePlural.toLowerCase() + "//" +
126 | typePlural.toUpperCase() + "/" + typePlural.toUpperCase() + ".TyPEs_PLURAL";
127 | assertEquals(fileName, fileNameConstructor.map2FileName(userObject));
128 | }
129 | }
130 |
131 | @Test
132 | public void testApplyExtensionRules() {
133 | Map extensionMap = new HashMap();
134 | extensionMap.put("DEFAULT", "sql");
135 | extensionMap.put("VIEW", "vw");
136 | fileNameConstructor.setExtensionMap(extensionMap);
137 | UserObject userObject = new UserObject();
138 | userObject.setName("view01");
139 | userObject.setType("view");
140 | userObject.setSchema("");
141 | String fileName = FileNameConstructor.pluralaze(FileNameConstructor.abbreviate(userObject.getType())).replace(" ", "_") + "/" + userObject.getName() + ".vw";
142 | assertEquals(fileName, fileNameConstructor.map2FileName(userObject));
143 | }
144 |
145 | @Test(expected=IllegalStateException.class)
146 | public void testExtensionRulesWrongConfig() {
147 | Map extensionMap = new HashMap();
148 | extensionMap.put("VIEW", "vw");
149 | fileNameConstructor.setExtensionMap(extensionMap);
150 | UserObject userObject = new UserObject();
151 | userObject.setName("");
152 | userObject.setType("strange type");
153 | userObject.setSchema("");
154 | fileNameConstructor.map2FileName(userObject);
155 | }
156 |
157 |
158 | }
159 |
--------------------------------------------------------------------------------
/src/test/java/com/googlecode/scheme2ddl/db2/MainTestDb2.java:
--------------------------------------------------------------------------------
1 | package com.googlecode.scheme2ddl.db2;
2 |
3 | import org.junit.Test;
4 |
5 | import static org.junit.Assert.*;
6 |
7 | public class MainTestDb2 {
8 |
9 | @Test
10 | public void testExtractPortFromDbUrl (){
11 | String url = "user/pass@serverName:123:DbName";
12 | int port = Main.extractPortFromDbUrl(url);
13 | assertEquals(123, port);
14 | }
15 |
16 |
17 |
18 |
19 | }
--------------------------------------------------------------------------------
/src/test/java/com/googlecode/scheme2ddl/db2/filter/IsAlterTableAutoGeneratedPredicateTest.java:
--------------------------------------------------------------------------------
1 | package com.googlecode.scheme2ddl.db2.filter;
2 |
3 | import com.googlecode.scheme2ddl.db2.IsAlterTableAutoGeneratedPredicate;
4 | import com.googlecode.scheme2ddl.db2.domain.Db2LookInfo;
5 | import org.junit.Test;
6 |
7 | import static org.junit.Assert.assertFalse;
8 | import static org.junit.Assert.assertTrue;
9 |
10 | /**
11 | * @author ar
12 | * @since Date: 05.04.2015
13 | */
14 | public class IsAlterTableAutoGeneratedPredicateTest {
15 |
16 |
17 | IsAlterTableAutoGeneratedPredicate predicate = new IsAlterTableAutoGeneratedPredicate();
18 |
19 | @Test
20 | public void testAlterTableAutoIncrement() throws Exception {
21 | Db2LookInfo db2LookInfo = new Db2LookInfo();
22 | db2LookInfo.setObjName("A");
23 | db2LookInfo.setObjType("TABLE");
24 | db2LookInfo.setSqlOperation("ALTER");
25 | db2LookInfo.setSqlStmt("ALTER TABLE \"MY \".\"STUDENT\" ALTER COLUMN \"SID_ID\" RESTART WITH 100 ");
26 | assertFalse(predicate.evaluate(db2LookInfo));
27 |
28 | }
29 |
30 | @Test
31 | public void testAlterTableNotAutoincrement() throws Exception {
32 | Db2LookInfo db2LookInfo = new Db2LookInfo();
33 | db2LookInfo.setObjName("A");
34 | db2LookInfo.setObjType("TABLE");
35 | db2LookInfo.setSqlOperation("ALTER");
36 | db2LookInfo.setSqlStmt("ALTER TABLE \"MY \".\"ORG_TEMP\" \n" +
37 | "\tADD CONSTRAINT \"DEPTNAME\" CHECK \n" +
38 | "\t\t(LENGTH(RTRIM(DEPTNAME)) >0)\n" +
39 | "\tENFORCED\n" +
40 | "\tENABLE QUERY OPTIMIZATION ;");
41 | assertTrue(predicate.evaluate(db2LookInfo));
42 |
43 | }
44 | }
--------------------------------------------------------------------------------