1 package info.globalcode.sql.dk;

     2 

     3 import java.sql.Types;

     4 import java.util.ArrayList;

     5 import java.util.Collections;

     6 import java.util.HashMap;

     7 import java.util.List;

     8 import java.util.Map;

     9 

    10 /**

    11  *

    12  * @author Ing. František Kučera (frantovo.cz)

    13  */

    14 public class CLIParser {

    15 

    16 	public static final String TYPE_NAME_SEPARATOR = ":";

    17 	private final Map<String, Integer> types;

    18 

    19 	public CLIParser() {

    20 		Map<String, Integer> m = new HashMap<>();

    21 		m.put("int", Types.INTEGER);

    22 		m.put("string", Types.VARCHAR);

    23 		m.put("boolean", Types.BOOLEAN);

    24 		/**

    25 		 * TODO: more types

    26 		 */

    27 		types = Collections.unmodifiableMap(m);

    28 	}

    29 

    30 	public CLIOptions parseOptions(String[] args) {

    31 		CLIOptions options = new CLIOptions();

    32 

    33 		List<Integer> numberedTypes = new ArrayList<>();

    34 		Map<String, Integer> namedTypes = new HashMap<>();

    35 

    36 		for (int i = 0; i < args.length; i++) {

    37 			String arg = args[i];

    38 			switch (arg) {

    39 				case Tokens.TYPES:

    40 					String typesString = args[++i];

    41 

    42 					for (String oneType : typesString.split("\\s*,\\s*")) {

    43 						int sepatratorIndex = oneType.indexOf(TYPE_NAME_SEPARATOR);

    44 						if (sepatratorIndex == -1) {

    45 							numberedTypes.add(getType(oneType));

    46 						} else {

    47 							String namePart = oneType.substring(0, sepatratorIndex);

    48 							String typePart = oneType.substring(sepatratorIndex + TYPE_NAME_SEPARATOR.length(), oneType.length());

    49 							namedTypes.put(namePart, getType(typePart));

    50 						}

    51 					}

    52 					break;

    53 				case Tokens.NAME_PREFIX:

    54 					options.setNamePrefix(args[++i]);

    55 					break;

    56 				case Tokens.DB:

    57 					options.setDatabaseName(args[++i]);

    58 					break;

    59 				case Tokens.SQL:

    60 					options.setSql(args[++i]);

    61 					options.setCommandType(CLIOptions.COMMAND_TYPE.QUERY);

    62 					break;

    63 				case Tokens.SQL_UPDATE:

    64 				case Tokens.SQL_INSERT:

    65 					options.setSql(args[++i]);

    66 					options.setCommandType(CLIOptions.COMMAND_TYPE.UPDATE);

    67 					break;

    68 				case Tokens.BATCH:

    69 					options.setBatch(true);

    70 					break;

    71 				case Tokens.DATA: // --data is the last option

    72 					for (i++; i < args.length; i++) {

    73 						arg = args[i];

    74 

    75 						if (arg.startsWith(options.getNamePrefix())) {

    76 							String paramName = arg.substring(options.getNamePrefix().length());

    77 							String paramValue = args[++i];

    78 							options.addNamedParameter(new NamedParameter(paramName, paramValue, namedTypes.get(paramName)));

    79 						} else {

    80 							int paramIndex = options.getNumberedParameters().size();

    81 							int paramType;

    82 							try {

    83 								paramType = numberedTypes.get(paramIndex);

    84 							} catch (IndexOutOfBoundsException e) {

    85 								throw new IllegalArgumentException("Missing type for parameter #" + paramIndex, e);

    86 							} catch (NullPointerException e) {

    87 								throw new IllegalArgumentException("Invalid type definition for parameter #" + paramIndex, e);

    88 							}

    89 							options.addNumberedParameter(new Parameter(arg, paramType));

    90 						}

    91 					}

    92 					break;

    93 				default:

    94 					throw new IllegalArgumentException("Unknown option: " + arg);

    95 			}

    96 		}

    97 

    98 

    99 

   100 		return options;

   101 

   102 	}

   103 

   104 	public static class Tokens {

   105 

   106 		public static final String DB = "--db";

   107 		public static final String SQL = "--sql";

   108 		public static final String SQL_UPDATE = "--sql-update";

   109 		public static final String SQL_INSERT = "--sql-insert";

   110 		public static final String BATCH = "--batch";

   111 		public static final String DATA = "--data";

   112 		public static final String NAME_PREFIX = "--name-prefix";

   113 		public static final String TYPES = "--types";

   114 

   115 		private Tokens() {

   116 		}

   117 	}

   118 

   119 	private Integer getType(String typeString) {

   120 		return types.get(typeString);

   121 	}

   122 }