Java でのSQLプログラム

Question

Javaの課題で教えていただきたいです。

＜修正事項＞
・「select no lesson term from kenshu where no="1" and lesson="English"」とコン　ソールに入力するとエラーが起こる
・複数のカラムが指定された際でも、NOの列しか表示されない

下記のコードで、二つの修正事項が全く分かりません。。。
どなたか教えていただきたいです。。。

package HelloWorld5;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class Q75syusei {
public static Map<String, Map<Integer, String>> makeTable() {
int no = 3;

	Map<String, Map<Integer, String>> map = new HashMap<String, Map<Integer, String>>();
	Map<Integer, String> NO = new HashMap<Integer, String>();
	for (int i = 0; i < no; i++) {
		NO.put(i, Integer.toString(i));
	}

	Map<Integer, String> LESSON = new HashMap<Integer, String>();
	LESSON.put(0, "English");
	LESSON.put(1, "math");
	LESSON.put(2, "Music");

	Map<Integer, String> TERM = new HashMap<Integer, String>();
	TERM.put(0, "A");
	TERM.put(1, "B");
	TERM.put(2, "A");

	Map<Integer, String> RESULT = new HashMap<Integer, String>();
	RESULT.put(0, "90");
	RESULT.put(1, "50");
	RESULT.put(2, "120");

	map.put("NO", NO);
	map.put("LESSON", LESSON);
	map.put("TERM", TERM);
	map.put("RESULT", RESULT);

	return map;
}

public static void getSQL(List<String> checkSQL, boolean boo) {
	Map<String, Map<Integer, String>> tableMap = makeTable();

	int selectStartNum = checkSQL.indexOf("SELECT") + 1;
	int fromStartNum = checkSQL.indexOf("FROM") + 1;
	int whereStartNum = checkSQL.indexOf("WHERE") + 1;

	String[] selectstr = checkSQL.get(1).split(",");

	if (boo) {
		ArrayList<String> getSQLList = new ArrayList<String>();
		System.out.println(checkSQL);
		int count = whereStartNum;

		List<Integer> displayNnums = new ArrayList<Integer>();
		displayNnums.add(0);
		displayNnums.add(1);
		displayNnums.add(2);

		while (true) {
			String[] whereTmpStrings = checkSQL.get(count).split("=");
			List<Integer> delete = new ArrayList<Integer>();
			whereTmpStrings[1] = whereTmpStrings[1].substring(1, whereTmpStrings[1].length() - 1);
			for (int i = 0; i < displayNnums.size(); i++) {
				if (!tableMap.get(whereTmpStrings[0]).get(i).equals(whereTmpStrings[1])) {

					System.out.println(tableMap.get(whereTmpStrings[0]).get(i) + whereTmpStrings[1]);
					delete.add(i);
				}
			}

			for (Integer integer : delete) {
				displayNnums.remove(displayNnums.indexOf(integer));
			}

			try {
				checkSQL.get(count + 1);

			} catch (Exception e) {
				break;
			}
			count += 2;
		}
		for (int i = 0; i < selectstr.length; i++) {
			System.out.printf("%10s", selectstr[i]);
		}
		System.out.println();
		for (int i : displayNnums) {

			for (String string : selectstr) {
				System.out.printf("%10s", tableMap.get(string).get(i) + " ");
			}
			System.out.println();
		}

	} else {
		for (int i = 0; i < selectstr.length; i++) {
			System.out.printf("%10s", selectstr[i]);
		}
		System.out.println();
		System.out.println("--------------------------");
		for (int i = 0; i < tableMap.get("NO").size(); i++) {
			for (String string : selectstr) {
				System.out.printf("%10s", tableMap.get(string).get(i) + " ");
			}
			System.out.println();
		}
	}
}

public static String BB(String string) {
	return string.toUpperCase();
}

public static boolean karam(String string) {
	List<String> karamList = new ArrayList<String>(Arrays.asList("NO", "LESSON", "TERM", "RESULT"));
	return karamList.contains(string);

}

public static void selsectCheck(List<String> checkSQL) {

	int selectNum = checkSQL.indexOf("FROM");
	boolean booe = false;

	String[] tmpStrings = checkSQL.get(1).split(",");

	if (!checkSQL.get(0).equals("SELECT")) {
		System.out.println("SELECT句が正しくありません。");
		System.exit(0);
	} else if (checkSQL.get(1).equals("FROM")) {
		booe = true;
	} else {
		for (String string : tmpStrings) {
			booe = !karam(string);
		}
	}

	if (booe) {
		System.out.println("SELECT句の引数が正しくありません。");
		System.exit(0);
	}
}

public static void fromCheck(List<String> checkSQL) {
	int fromStartNum = checkSQL.indexOf("FROM") + 1;

	if (!checkSQL.contains("FROM")) {
		System.out.println("FROM句が正しくありません。");
		System.exit(0);
	}

	try {
		if (!checkSQL.get(fromStartNum).equals("KENSHU")) {
			System.out.println("FROM句の引数が正しくありません。");
			System.exit(0);
		}
	} catch (Exception e) {
		System.out.println("FROM句が正しくありません。");
		System.exit(0);
	}

}

public static void whereCheck(List<String> checkSQL) {
	int fromStartNum = checkSQL.indexOf("WHERE") + 1;
	boolean booe = false;

	int count = fromStartNum;

	String tmpFromSqlString = "";

	for (int i = fromStartNum; i < checkSQL.size(); i++) {
		tmpFromSqlString += checkSQL.get(i);
	}

	String[] FromSqlString = tmpFromSqlString.split("AND");
	int num = 0;

	while (true) {
		String[] whereTmpStrings = FromSqlString[num].split("=");

		if (!karam(whereTmpStrings[0])) {
			booe = true;
		} else if (whereTmpStrings.length != 2) {
			booe = true;
		} else {
			String[] tmpStrings = whereTmpStrings[1].split("");
			if (!tmpStrings[0].equals("\"") || !tmpStrings[tmpStrings.length - 1].equals("\"")) {
				booe = true;
			}
		}
		if (booe) {
			System.out.println("WHERE句の引数が正しくありません。");
			System.exit(0);
		}

		String tmp = "";
		try {
			tmp = FromSqlString[num + 1];
		} catch (Exception e) {
			break;
		}
		num++;

	}
}

public static void main(String[] args) {
	Scanner sc = new Scanner(System.in);
	System.out.println("SQLを入力してください。");
	boolean whereboo = false;

	String scstr = sc.nextLine();
	String[] sqlstr = scstr.split(" ");

	for (int i = 0; i < sqlstr.length; i++) {
		sqlstr[i] = BB(sqlstr[i]);
	}

	List<String> checkSQL = new ArrayList<String>(Arrays.asList(sqlstr));
	checkSQL.remove("");
	checkSQL.remove(" ");

	checkSQL.remove(",");
	selsectCheck(checkSQL);
	fromCheck(checkSQL);

	if (checkSQL.size() == checkSQL.indexOf("FROM") + 2) {

	} else {
		boolean boo = false;
		int fromEndNum = checkSQL.indexOf("FROM") + 1;

		if (!checkSQL.get(fromEndNum + 1).equals("WHERE")) {
			System.out.println("WHERE句が正しくありません。");
			System.exit(0);
		} else {
			for (String str : checkSQL) {
				if (str.contains("=")) {
					whereCheck(checkSQL);
					boo = true;
				}
				whereboo = true;
			}
			if (boo == false) {
				System.out.println("WHERE句の引数が正しくありません。");
				System.exit(0);
			}
		}
	}
	System.out.println("SQL は正しいです。");
	getSQL(checkSQL, whereboo);
}

}
ボールドテキスト

Comments

[m.ts10806]

課題　であれば出題者に質問すべきでは。いずれにしてもコンソールにSQLそのものを入力する意図がわかりません。Javaプログラムの実行ではないのですか？

[nasubikun]

Javaで簡易SQLをつくってみようという課題でした！出題者ではなく、こちらで教えていただける方がいらっしゃればいいと思い質問しています(⌒∇⌒)

[m.ts10806]

此処には赤の他人しかおらず出題者の意図を汲める回答者はおそらくいないので自己責任になります。
が、エラー内容提示されてないのと、コードのマークダウンが不十分なのと、ファイル毎に分けられてないのとで再現確認が困難です。再現確認できないと答えるのは難しいので、質問修正してください。（なので出題者に聞くのが一番確実で早い。）

[1T2R3M4]

https://teratail.com/help/avoid-asking
コードをください・デバッグしてください等の丸投げの質問
何かを作りたいのでコードを書いてほしい、学校の課題を解いてほしい等の質問は、具体的にプログラミングで困っている質問ではないと考え、推奨していません。

[jimbe]

これだけコード書いてて分からないというのはどういうことでしょう。
sql も似非ですし MySql 関係なさそうですからタグは要らないのでは。

[xebme]

簡易SQLの仕様はあるのですか。

[xebme]

引用符の中もupperCaseされますね。
例外はこれでなくなると思います。
if (displayNnums.contains(integer)) displayNnums.remove(displayNnums.indexOf(integer));
その他の問題は指摘しません。

Answer 1

質問の回答

・「select no lesson term from kenshu where no="1" and lesson="English"」とコン　ソールに入力するとエラーが起こる

前の列条件処理で既に削除された要素をdisplayNumから削除しようとしているから。修正コードは下記。

      for (Integer integer : delete) {
        if (displayNnums.contains(integer))
        displayNnums.remove(displayNnums.indexOf(integer));
      }

・複数のカラムが指定された際でも、NOの列しか表示されない

簡易SQLの仕様に依存します。select no lesson term from kenshuの列の区切り文字を[,]にすると正常実行します。区切り文字を[ ]も許すならバグ(今は許してSQLを実行しています)。許さないのなら構文エラー。

• バグの場合は字句解析、構文解析の両方を直して列の並びを全て取得できるようにします
  • String.split()だけで字句解析できる仕様にするか、字句解析を自作する
• 構文エラーにするなら、FROMを期待しているところに列名がくるとエラーにするなどの対策を講じる

アドバイス

• 簡易SQLの言語仕様を(BNFを使うなどして)明確にしたうえでプログラミングしてください
• 字句解析、構文解析などのコンパイラー技術を学んで適用してください
• このプログラムを簡潔にしてください
  • 使われない変数や、思いつきの構造、強引なコードが見られます

関数を使うSQL実行

コンパイラ技術は調べればいくらでも情報が出てきます。さてSQLの実行をどうするか。以下のように関数を使うことにしました。

<KENSHUテーブルのレコード>.stream().filter(<WHERE条件の適用>).map(<SELECT列の値取得>).toList();

質問のコードを変更してSQL実行をStreamと関数で行いました。コードの抜粋を追記しておきます。SQLTokenizerクラスは省略します。ご自分で補ってください。

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.function.BiPredicate;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class SimpleSQLInterpreter {
  static record lesson(String no, String name, String term, String result) {}
  static Map<String,List<lesson>> tables = Map.of(
     "KENSHU", List.of(
        new lesson("0","English","A","90"),
        new lesson("1","Math","B","50"),
        new lesson("2","Music","A","120")
     )
  );
  static Map<String,Function<lesson,String>> columners = Map.of(
      "NO", x ->  x.no(),
      "LESSON", x -> x.name(),
      "TERM", x -> x.term(),
      "RESULT", x -> x.result()    
  ); 
  static Map<String,BiPredicate<String,String>> relOperators = Map.of(
      "=", (x,y) -> x != null && x.compareTo(y) == 0,
      "<", (x,y) -> x != null && x.compareTo(y) < 0,
      "<=", (x,y) -> x != null && x.compareTo(y) <= 0,
      ">", (x,y) -> x != null && x.compareTo(y) > 0,
      ">=", (x,y) -> x != null && x.compareTo(y) >= 0
  );
  static Map<String,BinaryOperator<Predicate<lesson>>> logicalOperators = Map.of(
      "AND", (x,y) -> x == null ? y : x.and(y),
      "OR", (x,y) -> x == null ? y : x.or(y)
  );
  /* SQLを実行する **/
  public static List<String> goSQL(String tableName, Predicate<lesson> conditions, Function<lesson,String> columns) {
    List<lesson> kenshu = tables.get(tableName);
    // WHERE条件で選択(filter)、レコードから列を取り出す(map)
    return kenshu.stream().filter(x -> conditions.test(x)).map(x -> columns.apply(x)).toList();
  } 
  public static Function<lesson,String> checkSelectClause(List<String> checkSQL) {
    List<Function<lesson,String>> columnList = new ArrayList<>();    
    int pos = 0;
    // ...
    // 列一覧を解析する
    // looping
      String col = checkSQL.get(pos).toUpperCase();
      if (!columners.containsKey(col)) {
        System.out.println("列["+col+"]が存在しません");
      }
      // ...
      columnList.add(columners.get(col));
    // ...   
    // lessonレコードから必要な列の値を取得して','で区切り表示する
    return x -> columnList.stream().map(f -> f.apply(x)).collect(Collectors.joining(",")).toString();
  }
  public static String checkFromClause(List<String> checkSQL) {
    int pos = 0;
    // ...
    String tableName = checkSQL.get(++pos).toUpperCase();
    if (!tables.containsKey(tableName)) {
      System.out.println("テーブルが存在しません");
    }
    // ...
    return tableName;
  }
  public static Predicate<lesson> checkWhereClause(List<String> checkSQL) {
    boolean notfound = true; // WHERE が存在しない
    // ...
    if (notfound) {
      return x -> true; // 全件選択
    }
    // WHERE が存在する
    Predicate<lesson> conditions = null;
    int s = 0;
    // 列選択条件を解析する
    // looping
      // 列名を解析する
      String col = checkSQL.get(s).toUpperCase();
      if (!columners.containsKey(col)) {
        System.out.println("列が存在しません");
      }
      // ...
      // 比較演算子を解析する
      String cnd = checkSQL.get(s+1);
      if (!relOperators.containsKey(cnd)) {
        System.out.println("比較演算子が不正です");
      }
      // ...
      BiPredicate<String,String> operator = relOperators.get(cnd);
      // ...
      // 文字列リテラルを解析する
      String evalue = checkSQL.get(s+2);
      // ... 
      // 列の値を比較して条件を満たすか判定する述語
      Predicate<lesson> p = x -> operator.test(columners.getOrDefault(col,c->"").apply(x),evalue);
      // AND結合 OR(?)　優先度は無視
      conditions = logicalOperators.get("AND").apply(conditions,p);    
    // ...
    return conditions;
  }
  public static void main(String[] args) { 
    try (Scanner sc = new Scanner(System.in)) {
      System.out.println("SQLを入力してください。");
      String scstr = sc.nextLine();
      // 字句解析
      List<String> checkSQL = SQLTokenizer.decompose(scstr);
      // 構文解析
      Function<lesson,String> selectColumns = null;
      String tableName = null;
      Predicate<lesson> conditions = null;
      // ...
      System.out.println("SQL は正しいです。");
      System.out.println(goSQL(tableName,conditions,selectColumns));
    }    
  }
}