Skip to content

Commit 6ae6ee0

Browse files
DevinFalgoustDevinFalgoust
committed
Added basic Select Query Functionality
- Added Basic Select Query Functionality - Added the classes needed for this functionality - Added Select Query Demo in Driver - Updated Readme
1 parent bf320f5 commit 6ae6ee0

File tree

6 files changed

+367
-3
lines changed

6 files changed

+367
-3
lines changed

‎Driver.java

Lines changed: 94 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,8 @@
1+
import devinfalgoust.sqlquerygenerator.QueryException;
12
import devinfalgoust.sqlquerygenerator.insert.InsertQueryFieldType;
23
import devinfalgoust.sqlquerygenerator.insert.InsertQueryGenerator;
4+
import devinfalgoust.sqlquerygenerator.select.SelectQueryFieldOperator;
5+
import devinfalgoust.sqlquerygenerator.select.SelectQueryGenerator;
36

47
/**
58
* This is the Driver class, containing the main function
@@ -10,7 +13,8 @@
1013
public class Driver {
1114

1215
public static void main(String args[]) {
13-
demoInsertQueryGenerator();
16+
//demoInsertQueryGenerator();
17+
demoSelectQueryGenerator();
1418
}
1519

1620
/**
@@ -72,4 +76,93 @@ public static void demoInsertQueryGenerator() {
7276
System.out.println(generator.generate());
7377
}
7478

79+
/**
80+
* This function provides sample code for the SelectQueryGenerator
81+
*/
82+
public static void demoSelectQueryGenerator() {
83+
try {
84+
// Generate Simple Select Query
85+
System.out.println("-- Generate Simple Select Query");
86+
SelectQueryGenerator generator = new SelectQueryGenerator("TEST_TABLE");
87+
System.out.println(generator.generate());
88+
89+
// Generate Query with One Select Field
90+
System.out.println("\n-- Generate Query with One Select Field");
91+
generator = new SelectQueryGenerator("TEST_TABLE");
92+
generator.addSelectField("orderId");
93+
System.out.println(generator.generate());
94+
95+
// Generate Query with Three Select Field
96+
System.out.println("\n-- Generate Query with Three Select Field");
97+
generator = new SelectQueryGenerator("TEST_TABLE");
98+
generator.addSelectField("orderId");
99+
generator.addSelectField("firstName");
100+
generator.addSelectField("lastName");
101+
System.out.println(generator.generate());
102+
103+
// Generate Distinct Query
104+
System.out.println("\n-- Generate Distinct Query");
105+
generator = new SelectQueryGenerator("TEST_TABLE");
106+
generator.addSelectField("lastName");
107+
generator.makeDistinct();
108+
System.out.println(generator.generate());
109+
110+
// Generate Query with One Where Clause
111+
System.out.println("\n-- Generate Query with One Where Clause");
112+
generator = new SelectQueryGenerator("TEST_TABLE");
113+
generator.addWhereField("orderId", SelectQueryFieldOperator.EQUAL, "4815162342");
114+
System.out.println(generator.generate());
115+
116+
// Generate Query with Three Where Clauses
117+
System.out.println("\n-- Generate Query with Three Where Clauses");
118+
generator = new SelectQueryGenerator("TEST_TABLE");
119+
generator.addWhereField("firstName", SelectQueryFieldOperator.EQUAL, "John");
120+
generator.addWhereField("lastName", SelectQueryFieldOperator.EQUAL, "Doe");
121+
generator.addWhereField("birthday", SelectQueryFieldOperator.EQUAL, "0424");
122+
System.out.println(generator.generate());
123+
124+
// Generate Query with One OrderBy
125+
System.out.println("\n-- Generate Query with One OrderBy");
126+
generator = new SelectQueryGenerator("TEST_TABLE");
127+
generator.addOrderByField("lastName");
128+
System.out.println(generator.generate());
129+
130+
// Generate Query with Three OrderBys
131+
System.out.println("\n-- Generate Query with Three OrderBys");
132+
generator = new SelectQueryGenerator("TEST_TABLE");
133+
generator.addOrderByField("lastName");
134+
generator.addOrderByField("firstName");
135+
generator.addOrderByField("email");
136+
System.out.println(generator.generate());
137+
138+
// Generate Query with One OrderBy Ascending
139+
System.out.println("\n-- Generate Query with One OrderBy");
140+
generator = new SelectQueryGenerator("TEST_TABLE");
141+
generator.addOrderByField("lastName");
142+
generator.makeOrderByAscending();
143+
System.out.println(generator.generate());
144+
145+
// Generate Query with One OrderBy Descending
146+
System.out.println("\n-- Generate Query with One OrderBy");
147+
generator = new SelectQueryGenerator("TEST_TABLE");
148+
generator.addOrderByField("lastName");
149+
generator.makeOrderByDescending();
150+
System.out.println(generator.generate());
151+
} catch (QueryException e) {
152+
System.err.println("-- I Should not get here");
153+
}
154+
155+
try {
156+
// Try to Generate Distinct Query without Select Fields
157+
System.out.println("\n-- Try to Generate Distinct Query without Select Fields");
158+
SelectQueryGenerator generator = new SelectQueryGenerator("TEST_TABLE");
159+
generator.makeDistinct();
160+
System.out.println(generator.generate());
161+
System.err.println("-- I Should not get here");
162+
163+
} catch (QueryException e) {
164+
System.err.println("-- This failed because Distinct was selected without any Select Fields");
165+
}
166+
}
167+
75168
}

‎README.md

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2,8 +2,11 @@ SQLQueryGenerator
22
==========
33

44
This is a simple program created to generate a large amount of test SQL Queries very quickly.
5-
It currently only has the Insert Query Generator implemented, but I can potentially create
6-
more Query Generators as the need arises.
5+
Currently only the Insert Query Generator is completely implemented.
6+
7+
The Select Query Generator has its basic functionality built, but is not feature complete.
8+
It currently does not support the OR operator, the BETWEEN or IN operators, multiple values in
9+
a given where clause, and it currently does not provide type safety on any where operators.
710

811
Instructions on how to use this are included in the Driver.java file
912

‎select/SelectQuery.java

Lines changed: 141 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,141 @@
1+
package devinfalgoust.sqlquerygenerator.select;
2+
3+
import java.util.List;
4+
5+
import devinfalgoust.sqlquerygenerator.Query;
6+
7+
public class SelectQuery implements Query {
8+
9+
private String tableName;
10+
private Boolean distinct;
11+
private List<String> selectFields;
12+
private List<SelectQueryField> whereFields;
13+
private List<String> orderByFields;
14+
private Boolean ascending;
15+
16+
public SelectQuery(String tableName) {
17+
this.tableName = tableName;
18+
distinct = Boolean.FALSE;
19+
ascending = null;
20+
}
21+
22+
@Override
23+
public String generate() {
24+
StringBuilder queryBuilder = new StringBuilder();
25+
26+
queryBuilder.append("SELECT ");
27+
28+
if (distinct) {
29+
queryBuilder.append("DISTINCT ");
30+
}
31+
32+
if (selectFields.isEmpty()) {
33+
queryBuilder.append("*");
34+
} else {
35+
for (int i = 0; i < selectFields.size(); i++) {
36+
queryBuilder.append(selectFields.get(i));
37+
if (i < selectFields.size() - 1) {
38+
queryBuilder.append(", ");
39+
}
40+
}
41+
}
42+
43+
queryBuilder.append(" FROM ").append(tableName);
44+
45+
if (!whereFields.isEmpty()) {
46+
queryBuilder.append(" WHERE ");
47+
for (int i = 0; i < whereFields.size(); i++) {
48+
SelectQueryField field = whereFields.get(i);
49+
50+
queryBuilder.append(field.getName());
51+
52+
switch (whereFields.get(i).getOperator()) {
53+
case EQUAL:
54+
queryBuilder.append(" = ");
55+
break;
56+
57+
case NOT_EQUAL:
58+
queryBuilder.append(" <> ");
59+
break;
60+
61+
case GREATER_THAN:
62+
queryBuilder.append(" > ");
63+
break;
64+
65+
case GREATER_THAN_OR_EQUAL:
66+
queryBuilder.append(" >= ");
67+
break;
68+
69+
case LESS_THAN:
70+
queryBuilder.append(" < ");
71+
break;
72+
73+
case LESS_THAN_OR_EQUAL:
74+
queryBuilder.append(" <= ");
75+
break;
76+
77+
case LIKE:
78+
queryBuilder.append(" LIKE ");
79+
break;
80+
81+
default:
82+
// Should never reach here
83+
break;
84+
}
85+
86+
if(field.isString()) {
87+
queryBuilder.append("'").append(field.getStringValue()).append("'");
88+
} else {
89+
queryBuilder.append(field.getIntValue().toString());
90+
}
91+
92+
if (i < whereFields.size() - 1) {
93+
queryBuilder.append(" AND ");
94+
}
95+
}
96+
}
97+
98+
if (!orderByFields.isEmpty()) {
99+
queryBuilder.append(" ORDER BY ");
100+
for (int i = 0; i < orderByFields.size(); i++) {
101+
queryBuilder.append(orderByFields.get(i));
102+
if (i < orderByFields.size() - 1) {
103+
queryBuilder.append(", ");
104+
}
105+
}
106+
}
107+
108+
if (ascending != null) {
109+
if (ascending) {
110+
queryBuilder.append(" ASC");
111+
} else {
112+
queryBuilder.append(" DESC");
113+
}
114+
}
115+
116+
queryBuilder.append(";");
117+
118+
return queryBuilder.toString();
119+
}
120+
121+
public void setDistinct(Boolean distinct) {
122+
this.distinct = distinct;
123+
}
124+
125+
public void setAscending(Boolean ascending) {
126+
this.ascending = ascending;
127+
}
128+
129+
public void setSelectFields(List<String> selectFields) {
130+
this.selectFields = selectFields;
131+
}
132+
133+
public void setWhereFields(List<SelectQueryField> whereFields) {
134+
this.whereFields = whereFields;
135+
}
136+
137+
public void setOrderByFields(List<String> orderByFields) {
138+
this.orderByFields = orderByFields;
139+
}
140+
141+
}

‎select/SelectQueryField.java

Lines changed: 46 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,46 @@
1+
package devinfalgoust.sqlquerygenerator.select;
2+
3+
public class SelectQueryField {
4+
5+
private String name;
6+
private SelectQueryFieldOperator operator;
7+
private String stringValue;
8+
private Integer intValue;
9+
10+
public SelectQueryField(String name, SelectQueryFieldOperator operator, String value) {
11+
this.name = name;
12+
this.operator = operator;
13+
stringValue = value;
14+
}
15+
16+
public SelectQueryField(String name, SelectQueryFieldOperator operator, Integer value) {
17+
this.name = name;
18+
this.operator = operator;
19+
intValue = value;
20+
}
21+
22+
public String getName() {
23+
return name;
24+
}
25+
26+
public SelectQueryFieldOperator getOperator() {
27+
return operator;
28+
}
29+
30+
public Boolean isString() {
31+
if(intValue == null) {
32+
return true;
33+
} else {
34+
return false;
35+
}
36+
}
37+
38+
public String getStringValue() {
39+
return stringValue;
40+
}
41+
42+
public Integer getIntValue() {
43+
return intValue;
44+
}
45+
46+
}

‎select/SelectQueryFieldOperator.java

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
package devinfalgoust.sqlquerygenerator.select;
2+
3+
public enum SelectQueryFieldOperator {
4+
5+
EQUAL, NOT_EQUAL,
6+
GREATER_THAN, GREATER_THAN_OR_EQUAL,
7+
LESS_THAN, LESS_THAN_OR_EQUAL,
8+
BETWEEN, LIKE, IN;
9+
10+
}

‎select/SelectQueryGenerator.java

Lines changed: 71 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,71 @@
1+
package devinfalgoust.sqlquerygenerator.select;
2+
3+
import java.util.ArrayList;
4+
import java.util.List;
5+
6+
import devinfalgoust.sqlquerygenerator.QueryException;
7+
8+
public class SelectQueryGenerator {
9+
10+
private String tableName;
11+
private Boolean distinct;
12+
private List<String> selectFields;
13+
private List<SelectQueryField> whereFields;
14+
private List<String> orderByFields;
15+
private Boolean ascending;
16+
17+
public SelectQueryGenerator(String tableName) {
18+
this.tableName = tableName;
19+
distinct = Boolean.FALSE;
20+
selectFields = new ArrayList<String>();
21+
whereFields = new ArrayList<SelectQueryField>();
22+
orderByFields = new ArrayList<String>();
23+
ascending = null;
24+
}
25+
26+
public String generate() throws QueryException {
27+
SelectQuery query = new SelectQuery(tableName);
28+
29+
if (distinct) {
30+
if (selectFields.isEmpty()) {
31+
throw new QueryException();
32+
}
33+
query.setDistinct(distinct);
34+
}
35+
36+
query.setSelectFields(selectFields);
37+
query.setWhereFields(whereFields);
38+
query.setOrderByFields(orderByFields);
39+
40+
if (ascending != null) {
41+
query.setAscending(ascending);
42+
}
43+
44+
return query.generate();
45+
}
46+
47+
public void addSelectField(String field) {
48+
selectFields.add(field);
49+
}
50+
51+
public void addWhereField(String name, SelectQueryFieldOperator operator, String value) {
52+
whereFields.add(new SelectQueryField(name, operator, value));
53+
}
54+
55+
public void addOrderByField(String field) {
56+
orderByFields.add(field);
57+
}
58+
59+
public void makeDistinct() {
60+
distinct = Boolean.TRUE;
61+
}
62+
63+
public void makeOrderByAscending() {
64+
ascending = Boolean.TRUE;
65+
}
66+
67+
public void makeOrderByDescending() {
68+
ascending = Boolean.FALSE;
69+
}
70+
71+
}

0 commit comments

Comments
 (0)