Source code

001
002package gudusoft.gsqlparser.util;
003
004import gudusoft.gsqlparser.EDbVendor;
005
006import java.util.*;
007
008public class keywordChecker {
009
010    private static final String COMMA = ",";
011    private static final String MINUS = "-";
012
013    public static enum keywordType {
014        reserved_keyword, non_reserved_keyword, not_a_keyword;
015    }
016
017    private keywordChecker() {
018    }
019
020        public static LinkedHashMap<String, keywordType> checkKeywordType(String inputString, EDbVendor dbvendor) {
021                LinkedHashMap<String, keywordType> keywordTypes = new LinkedHashMap<>();
022                if (inputString == null || inputString.trim().equals(""))
023                        return keywordTypes;
024                String latestVersion = getDbLatestVersion(dbvendor);
025                if (SQLUtil.isEmpty(latestVersion)) {
026                        return keywordTypes;
027                }
028
029                keywordList keywordList = keywordListFactory.getInstance()
030                                .getDbKeywordList(dbvendor, latestVersion);
031                if (keywordList == null) {
032                        return keywordTypes;
033                }
034
035                for (String word : inputString.split("\\s*,\\s*")) {
036                        word = word.toUpperCase().trim();
037                        if (keywordList.getReservedList().contains(word)) {
038                                keywordTypes.put(word, keywordType.reserved_keyword);
039                        } else if (keywordList.getKeywordList().contains(word)) {
040                                keywordTypes.put(word, keywordType.non_reserved_keyword);
041                        } else {
042                                keywordTypes.put(word, keywordType.not_a_keyword);
043                        }
044                }
045                return keywordTypes;
046        }
047
048    /**
049     * @param dbVersion, available database version can be check via {@link #getAvailableDbVersions(gudusoft.gsqlparser.EDbVendor)}
050     */
051    public static boolean isKeyword(String inputString, EDbVendor dbvendor,
052                                    String dbVersion, boolean reservedOnly) {
053        if (inputString == null || inputString.trim().equals(""))
054            return false;
055
056        String keyword = inputString.toUpperCase();
057
058        keywordList keywordList = keywordListFactory.getInstance()
059                .getDbKeywordList(dbvendor, dbVersion);
060        if (keywordList == null) {
061            throw new IllegalArgumentException("Can't get available keyword list");
062        }
063
064        if (reservedOnly)
065            return keywordList.getReservedList().contains(keyword);
066        else
067            return keywordList.getKeywordList().contains(keyword);
068    }
069
070    public static String getKeywordList(EDbVendor dbvendor, String dbVersion,
071                                        boolean reservedOnly) {
072        keywordList keywordList = keywordListFactory.getInstance()
073                .getDbKeywordList(dbvendor, dbVersion);
074        if (keywordList == null) {
075            throw new IllegalArgumentException("Can't get available keyword list");
076        }
077
078        List<String> keywords = null;
079        if (reservedOnly)
080            keywords = keywordList.getReservedList();
081        else
082            keywords = keywordList.getKeywordList();
083
084        if (keywords != null) {
085            StringBuffer buffer = new StringBuffer();
086            for (int i = 0; i < keywords.size(); i++) {
087                if (i < keywords.size() - 1)
088                    buffer.append(keywords.get(i)).append(COMMA);
089                else
090                    buffer.append(keywords.get(i));
091            }
092            return buffer.toString();
093        }
094        return null;
095    }
096
097    public static String compareKeywordList(EDbVendor dbvendor1,
098                                            String dbVersion1, EDbVendor dbvendor2, String dbVersion2,
099                                            boolean reservedOnly) {
100        keywordList keywordList1 = keywordListFactory.getInstance()
101                .getDbKeywordList(dbvendor1, dbVersion1);
102        keywordList keywordList2 = keywordListFactory.getInstance()
103                .getDbKeywordList(dbvendor2, dbVersion2);
104
105        if (keywordList1 == null || keywordList2 == null) {
106            throw new IllegalArgumentException("Can't get available keyword list");
107        }
108
109        List<String> list1 = new ArrayList<String>();
110        List<String> list2 = new ArrayList<String>();
111        List<String> retainList = new ArrayList<String>();
112
113        if (reservedOnly) {
114            retainList.addAll(keywordList1.getReservedList());
115            retainList.retainAll(keywordList2.getReservedList());
116            list1.addAll(keywordList1.getReservedList());
117            list2.addAll(keywordList2.getReservedList());
118        } else {
119            retainList.addAll(keywordList1.getKeywordList());
120            retainList.retainAll(keywordList2.getKeywordList());
121            list1.addAll(keywordList1.getKeywordList());
122            list2.addAll(keywordList2.getKeywordList());
123        }
124
125        list1.removeAll(retainList);
126        list2.removeAll(retainList);
127
128        for (int i = 0; i < list2.size(); i++) {
129            list1.add(MINUS + list2.get(i));
130        }
131
132        Collections.sort(list1, new Comparator<String>() {
133
134            public int compare(String str1, String str2) {
135                if (!str1.startsWith(MINUS))
136                    str1 = MINUS + str1;
137                if (!str2.startsWith(MINUS))
138                    str2 = MINUS + str2;
139                return str1.compareToIgnoreCase(str2);
140            }
141
142        });
143
144        StringBuffer buffer = new StringBuffer();
145        for (int i = 0; i < list1.size(); i++) {
146            buffer.append(list1.get(i));
147            if (i < list1.size() - 1)
148                buffer.append(COMMA);
149        }
150        return buffer.toString();
151    }
152
153    /**
154     * <table summary="">
155     *         <tr>
156     *             <th>Database</th>
157     *             <th>Supported Versions</th>
158     *         </tr>
159     *         <tr>
160     *             <td>MySQL</td>
161     *             <td>5.4, 5.7, 5.0, 4.1, 5.5, 5.3, 3.23, 5.1, 5.6, 6.0, 5.2, 4.0</td>
162     *         </tr>
163     *         <tr>
164     *             <td>MSSQL</td>
165     *             <td>10.5, 10.0, 8.0, 9.0, 12.0</td>
166     *         </tr>
167     *         <tr>
168     *             <td>Netezza</td>
169     *             <td>5.0, 6.0, 4.6.5</td>
170     *         </tr>
171     *         <tr>
172     *             <td>Oracle</td>
173     *             <td>10, 11.1, 9, 11.2, 8</td>
174     *         </tr>
175     *         <tr>
176     *             <td>ODBC</td>
177     *             <td>ODBC</td>
178     *         </tr>
179     *         <tr>
180     *             <td>PostgreSQL</td>
181     *             <td>8.2, 9.3, 7.4, 9.0, 7.1, 8.3, 9.1, 8.4, 7.2, 8.0, 7.3, 9.2, 8.1</td>
182     *         </tr>
183     *         <tr>
184     *             <td>Sybase</td>
185     *             <td>12.5, 15.5, 15.0, 15.7</td>
186     *         </tr>
187     *         <tr>
188     *             <td>Teradata</td>
189     *             <td>V2R3, 14.0, V2R6, V2R4, 12.0, 13.0, 13.1, V2R5.1, V2R5</td>
190     *         </tr>
191     *     </table>
192     */
193    public static List<String> getAvailableDbVersions(EDbVendor dbvendor) {
194        return keywordListFactory.getInstance()
195                .getAvailableDbVersions(dbvendor);
196    }
197
198    public static String getDbLatestVersion(EDbVendor dbvendor) {
199        return keywordListFactory.getInstance()
200                .getDbLatestVersion(dbvendor);
201    }
202
203    public static boolean containsDbVersion(EDbVendor dbvendor,
204                                            String dbVersion) {
205        return keywordListFactory.getInstance().containsDbVersion(dbvendor,
206                dbVersion);
207    }
208
209    public static void main(String[] args) {
210        keywordChecker.getAvailableDbVersions(EDbVendor.dbvsybase)
211                .size();
212        keywordChecker.getKeywordList(EDbVendor.dbvsybase, "15.7", false);
213        keywordChecker.getKeywordList(EDbVendor.dbvsybase, "12.5", false);
214
215        long time = System.currentTimeMillis();
216        String keywordStr = keywordChecker.getKeywordList(EDbVendor.dbvsybase,
217                "15.7",
218                false);
219        String[] keywords = keywordStr.split(",");
220        for (int i = 0; i < keywords.length; i++) {
221            boolean flag = keywordChecker.isKeyword(keywords[i].trim(),
222                    EDbVendor.dbvsybase,
223                    "15.7",
224                    false);
225            if (!flag) {
226                System.out.println(keywords[i] + "'s status is error");
227            }
228        }
229        keywordChecker.compareKeywordList(EDbVendor.dbvsybase,
230                "15.7",
231                EDbVendor.dbvsybase,
232                "12.5",
233                false);
234        System.out.println("Time="
235                + (System.currentTimeMillis() - time)
236                + "ms");
237    }
238}