commit 0f64ed400cab83fc07ca4cbdfc3bc4dc75a96c01 Author: José Henrique Date: Thu Nov 23 22:25:20 2023 -0300 add base diff --git a/__pycache__/sql.cpython-310.pyc b/__pycache__/sql.cpython-310.pyc new file mode 100644 index 0000000..abc1170 Binary files /dev/null and b/__pycache__/sql.cpython-310.pyc differ diff --git a/__pycache__/sql.cpython-311.pyc b/__pycache__/sql.cpython-311.pyc new file mode 100644 index 0000000..ea1e203 Binary files /dev/null and b/__pycache__/sql.cpython-311.pyc differ diff --git a/__pycache__/table.cpython-310.pyc b/__pycache__/table.cpython-310.pyc new file mode 100644 index 0000000..b9dc2e5 Binary files /dev/null and b/__pycache__/table.cpython-310.pyc differ diff --git a/__pycache__/table.cpython-311.pyc b/__pycache__/table.cpython-311.pyc new file mode 100644 index 0000000..f011608 Binary files /dev/null and b/__pycache__/table.cpython-311.pyc differ diff --git a/java/BancoDeDados.java b/java/BancoDeDados.java new file mode 100644 index 0000000..d723038 --- /dev/null +++ b/java/BancoDeDados.java @@ -0,0 +1,54 @@ +/* + * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license + * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template + */ +package trabalhobd; + +import java.util.ArrayList; +import java.util.List; +import java.util.Queue; + +/** + * + * @author julioc7r + */ +public class BancoDeDados { + List lista_tabelas; + int n_tabelas; + SQL pesquisa; + + public BancoDeDados() { + this.lista_tabelas = new ArrayList(); + this.n_tabelas = 0; + } + + public List getLista_tabelas() { + return lista_tabelas; + } + + public void setLista_tabelas(List lista_tabelas) { + this.lista_tabelas = lista_tabelas; + } + + public int getN_tabelas() { + return n_tabelas; + } + + public void setN_tabelas(int n_tabelas) { + this.n_tabelas = n_tabelas; + } + + public SQL getPesquisa() { + return pesquisa; + } + + public void setPesquisa(Queue query,List lista_tabelas) { + this.pesquisa = new SQL(query,lista_tabelas); + } + + public void executaSQL(Queue query){ + setPesquisa(query, this.lista_tabelas); + pesquisa.resultadoQuery(); + } + +} diff --git a/java/README.md b/java/README.md new file mode 100644 index 0000000..1ae2802 --- /dev/null +++ b/java/README.md @@ -0,0 +1,12 @@ +# jcSQL + +Tentativa de criar um Banco de Dados que aceita alguns comandos SQL em Java. + +A proposta do Trabalho 1 da disciplina de Banco de Dados, foi a de codificar um Banco de Dados em memória para que tenhamos melhor compreensão dos processos que acontencem dentro de um DataBase. + +Comandos Suportados: + +Select, From, Where, Order By + +*os filtros do Where( < , > , = , != ) + diff --git a/java/SQL.java b/java/SQL.java new file mode 100644 index 0000000..5c0760d --- /dev/null +++ b/java/SQL.java @@ -0,0 +1,588 @@ +/* + * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license + * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template + */ +package trabalhobd; + +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; +import java.util.Queue; + +/** + * + * @author julioc7r + */ +public class SQL { + Queue query; + List lista_tabelas; + List selectList; + List fromList; + List whereList; + List joinList; + Boolean whereFlag; + Boolean orderBy; + String chaveOrder; + + public SQL(Queue query,List lista_tabelas) { + this.query = query; + this.selectList = new LinkedList(); + this.fromList = new LinkedList(); + this.whereList = new LinkedList(); + this.joinList = new LinkedList(); + this.orderBy = false; + this.whereFlag = false; + this.chaveOrder = null; + this.lista_tabelas = lista_tabelas; + + } + + public Queue getQuery() { + return query; + } + + public void setQuery(Queue query) { + this.query = query; + } + + public Boolean getOrderBy() { + return orderBy; + } + + public void setOrderBy(Boolean orderBy) { + this.orderBy = orderBy; + } + + public void processamentoQuery() { + + for(int i = 0;this.query.isEmpty() == false; i++) + { + System.out.println("Fila["+i +"] = "+ this.query.peek()); + if(this.query.peek().equals("select")){ //SE ENTROU salva na selectList os atributos requiridos + i++;//para printar a ordem dos elementos + this.query.poll(); + int j=0; + while(isCommand(query.peek())== false){ + System.out.println(this.query.peek()+" - "+ "LISTA VAZIA" +j); + System.out.println("Fila["+i +"] = "+ this.query.peek()); + i++; + this.selectList.add(this.query.poll()); + System.out.println(this.query.peek()+" - "+this.selectList.get(j)); + j++; + } + } + if(this.query.peek().equals("from")){ //SE ENTROU salva na fromList os atributos requiridos + i++; + this.query.poll(); + int j=0; + while(isCommand(query.peek())== false){ + System.out.println(this.query.peek()+" - "+"LISTA VAZIA" +j); + System.out.println("Fila["+i +"] = "+ this.query.peek()); + i++; + this.fromList.add(this.query.poll()); + System.out.println(this.query.peek()+" - "+this.fromList.get(j)); + j++; + } + } + + if(this.query.peek()!=null && this.query.peek().equals("on")){ //SE ENTROU salva na fromList os atributos requiridos + i++; + this.query.poll(); + int j=0; + while(isCommand(query.peek())== false){ + System.out.println(this.query.peek()+" - "+"LISTA VAZIA" +j); + System.out.println("Fila["+i +"] = "+ this.query.peek()); + i++; + this.joinList.add(this.query.poll()); + System.out.println(this.query.peek()+" - "+this.joinList.get(j)); + j++; + } + } + + if(this.query.peek()!=null && this.query.peek().equals("where")){ //SE ENTROU salva na whereList os atributos requiridos + this.whereFlag = true; + i++; + this.query.poll(); + int j=0; + while(isCommand(query.peek())== false){ + System.out.println(this.query.peek()+" - "+"LISTA VAZIA" +j); + System.out.println("Fila["+i +"] = "+ this.query.peek()); + i++; + this.whereList.add(this.query.poll()); + //System.out.println(this.query.peek()+" - "+this.whereList.get(j)); + j++; + if(query.isEmpty()){ + return;} + } + } + if(this.query.peek()!=null && this.query.peek().equals("order")){ //SE ENTROU define o elemento pelo qual a lista será ordenada + i+=2; + this.query.poll();// elimina o "ORDER" da fila + this.query.poll();// elimina o "BY" da fila + this.orderBy = true; + this.chaveOrder = this.query.poll(); + System.out.println("Fila["+i +"] = "+"CHAVE = "+ this.chaveOrder); + } + } + } + + public void resultadoQuery(){ + //Pensar em como fazer + processamentoQuery(); + int whereTabelaPos = -1; + + + //ENCONTRA AS TABELAS USADAS + List tabelas = new LinkedList(); + System.out.println("LAOSLKDOAKSDOAKS"+this.lista_tabelas.size()); + for(int i = 0; i tabelaResultado = new LinkedList<>();//n_elementos*n_linhas); + + + int[] tam = new int[n_elementos]; + + System.out.println( "QQQQ "+ n_elementos); + //n_elementos--; + + + boolean joinONList = false; + if(this.selectList.get(0).contains("*") && fromList.size() == 1){ + for(int j = 0; j < n_elementos ; j++){ + tam[j] = j; + } + } + else if(this.selectList.get(0).contains("*") && fromList.size() > 1){ + int k = 0; + for(int i = 0; i < fromList.size();i++){ + for(int j = 0; j < this.lista_tabelas.get(pos_tabela[i]).getColunas() ; j++){ + tam[k] = j; + k++; + } + } + } + else{ + for (int i = 0; i < pos_tabela.length ; i++){ + for(int j = 0; j < n_elementos ; j++){ + tam[j] = this.lista_tabelas.get(pos_tabela[i]).getColunaPeloNome(this.selectList.get(j)); + System.out.println(tam[j] + "QQQ "+ n_elementos); + if(tam[j]==99){// PERCORREU A TABELA E NÃO ACHOU + System.out.println(" ELEMENTO NÃO ENCONTRADO!!"); + return; + } + if((whereFlag==true) && (this.selectList.get(j).contains(whereList.get(0)))){ + whereTabelaPos = j; + } + } + } + } + + + if(fromList.size()>1){ // FAZ O JOIN SE A FROMLIST POSSUIR MAIS DE DOIS ELEMENTOS(IMPLEMENTAMOS PARA FUNCIONAR COM 2 ELEMENTOS) + tabelaResultado = nestedLoopJoin(tabelaResultado,pos_tabela,tam,quantidadePorTabela); + if(whereFlag==true){ + for(int k = 0; k < pos_tabela.length ; k++){ + for(int i = 0 ; i < n_linhas;i++){ + for(int j = 0 ; j < n_elementos ; j++){ + if(comparaWhere(this.lista_tabelas.get(pos_tabela[k]).getElemento(tam[whereTabelaPos]))==true){ + tabelaResultado.add(this.lista_tabelas.get(pos_tabela[k]).getElemento(tam[j])); + } + else if(tabelaResultado.size() tabela, int tam_colunas){ + int tam = tam_colunas; + int ordenado = 0; + while(ordenado==1){ + ordenado = 1; + for(int i = 0 ; i < tabela.size();i = i + tam_colunas){ + if(tabela.get(i).compareTo(tabela.get(i+tam_colunas))<0){ + for(int j = 0 ; j < tam_colunas ; j++){ + String swap = tabela.get(i+j); + tabela.set(i+j,tabela.get(i+j+tam_colunas)); + tabela.set(i+j+tam_colunas,swap); + } + ordenado = 0; + } + } + } + } + + private void printTabelaResultado(List tabelaResultado, int tcolunas, int tlinhas) { + int tam = 0; + System.out.println(" --------------------------------------------------------------"); + for(int i = 0; i < tlinhas ; i++){ + + for(int j = 0; j < tcolunas ; j++){ + System.out.print(" | " + tabelaResultado.get(tam)); + tam++; + } + System.out.print(" | "); + System.out.println("\n --------------------------------------------------------------"); + if(tabelaResultado.get(tam).contains("fim")){ + return; + } + } + } + + private int[] maiorTabela(int[] pos_tabela){ //VERIFICA A MENOR TABELA E COLOCA NA POSIÇÃO CENTRAL DO LOOP + + if(this.lista_tabelas.get(pos_tabela[0]).getLinhas() > this.lista_tabelas.get(pos_tabela[1]).getLinhas()){ + int aux = pos_tabela[0]; + pos_tabela[0] = pos_tabela[1]; + pos_tabela[1] = aux; + } + + return pos_tabela; + + } + + public List nestedLoopJoin(List tabelaResultado, int[] pos_tabela,int[] select_pos,int[] coluna_select){ + //TRABALHO 2 + pos_tabela = maiorTabela(pos_tabela); // A MAIOR TABELA RODA DENTRO DO LOOP DA MENOR TABELA + /* for each tuple t.r in r do begin + for each tuple t.s in s do begin + test pair (t.r,t.s) to see if they satisfy the join condition θ + if they do, add t.r • t.s to the result. + end + end + r is called the outer relation and s the inner relation of the join. + */ + + //select name from pessoa trabalho on cpf + + for(int i = 0; i< this.joinList.size() ; i++){ + + System.out.println("JOIN ON" +this.joinList.get(i)); + } + + int[] pos_join = new int[2]; // GUARDA A POSIÇÃ) DOS ELEMENTO CHAVE EM SUAS RESPECTIVAS TABELAS [0] = tabela1 ||||| [1] = tabela2 + + // pos_tabela -> posição da tabela na lista tabela + + for (int i = 0; i < pos_tabela.length ; i++){ + for(int j = 0; j < 2 ; j++){ + + pos_join[j] = this.lista_tabelas.get(pos_tabela[i]).getColunaPeloNome(this.joinList.get(0)); + + System.out.println(pos_join[j] + "LOOPcompareID TABELA - "+ i); + + if(pos_join[j]==99){// PERCORREU A TABELA E NÃO ACHOU + System.out.println(" ELEMENTO NÃO ENCONTRADO!!"); + return null; + } + } + } + + + //ADICIONANDO OS HEADERS + int p = 0; + for(int k = 0; k < select_pos.length; k++){ + System.out.println(pos_join[p] + "DENTRO DO LOOP K - " + k + " COLUNA "+ select_pos[k]+" P - " +p + this.lista_tabelas.get(pos_tabela[p]).getElemento(select_pos[k])); + if(k == (coluna_select[p]-1)){ + + p = 1; + } + tabelaResultado.add(this.lista_tabelas.get(pos_tabela[p]).getElemento(select_pos[k])); + select_pos[k] = select_pos[k] + this.lista_tabelas.get(pos_tabela[p]).getColunas(); + } + + + pos_join[0] = pos_join[0] + this.lista_tabelas.get(pos_tabela[0]).getColunas(); + pos_join[1] = pos_join[1] + this.lista_tabelas.get(pos_tabela[1]).getColunas(); + int aux = pos_join[0]; + int auxb = pos_join[1]; + + + int[] auxSelect = select_pos; + + for (int i = 0; i < select_pos.length ; i++){ + System.out.println(i + " DENTRO DO SELECT - "+ select_pos[i]); + } + + for(int i = 0 ; i < this.lista_tabelas.get(pos_tabela[0]).getLinhas();i++){ + //System.out.println( " i " + i ); + if(pos_join[0] > this.lista_tabelas.get(pos_tabela[0]).getTamanho()){ + break; + } + if(i>=1){ + pos_join[0] = aux +( i * this.lista_tabelas.get(pos_tabela[0]).getColunas()); + } + //System.out.println( " POSIÇAO DO JOIN i " + pos_join[0] ); + + for(int j = 0 ; j < this.lista_tabelas.get(pos_tabela[1]).getLinhas() ; j++){ + //System.out.println( " i " + i + " j " + j); + // System.out.println( " POSIÇAO DO JOIN j " + pos_join[1] ); + if(this.lista_tabelas.get(pos_tabela[0]).getElemento(pos_join[0]).contentEquals(this.lista_tabelas.get(pos_tabela[1]).getElemento(pos_join[1]))){ + p = 0; + + for(int k = 0; k < select_pos.length; k++){ + System.out.println(pos_join[p] + "DENTRO DO LOOP K - " + k + " COLUNA "+ select_pos[k]+" P - " +p + this.lista_tabelas.get(pos_tabela[p]).getElemento(select_pos[k])); + if(k == (coluna_select[p]-1)){ + + p = 1; + //System.out.println(pos_join[j] + "DENTRO DO LOOP K - " + k + " COLUNA "+ select_pos[k]+" P - " +p); + } + tabelaResultado.add(this.lista_tabelas.get(pos_tabela[p]).getElemento(select_pos[k])); + if(p==1){ + select_pos[k] = select_pos[k] + this.lista_tabelas.get(pos_tabela[p]).getColunas(); + } + + } + } + else{ + for(int k = 0; k < select_pos.length; k++){ + select_pos[k] = select_pos[k] + this.lista_tabelas.get(pos_tabela[p]).getColunas(); + } + } + + //Faz com que os elementos das colunas desejadas sejam achados. + pos_join[1] = pos_join[1] + this.lista_tabelas.get(pos_tabela[1]).getColunas(); + if(pos_join[1] > this.lista_tabelas.get(pos_tabela[1]).getTamanho()){ + break; + } + + } + for(int k = 0; k < coluna_select[0]; k++){ + select_pos[k] = select_pos[k] + this.lista_tabelas.get(pos_tabela[p]).getColunas(); + } + for(int k = coluna_select[0]; k < select_pos.length; k++){ + select_pos[k] = auxSelect[k]; + } + pos_join[1] = auxb; + } + return tabelaResultado; + + /* select * from trabalho pessoa on cpf TESTE + + DUAS FORMAS DE LER + + SELECT * + FROM tabela1, tabela2 + WHERE tabela1.id=tabela2.id + + SELECT * + FROM tabela1 + JOIN tabela2 + ON tabela1.Key = tabela2.Key + */ + } + + /* + + public void selection(List whereList,Tabela tabela){//PROCESSAMENTO DO WHERE + //{=, <, ≤, >, ≥, ≠} OPERADORES PARA TABELAS ORDENADAS + //{=, ≠} OPERADORES PARA VALORES DESORDENADOS + int i = 0; + + if(whereList.get(i).contentEquals("=")){ + tabela = tabela.comparaIgual(tabela,elemento,chave); + } + else if(whereList.get(i).contentEquals("!=")){ + tabela = tabela.comparaDiferente(tabela,elemento,chave); + } + else if(whereList.get(i).contentEquals(">")){ + tabela = tabela.comparaMaior(tabela,elemento,chave); + } + else if(whereList.get(i).contentEquals("<")){ + tabela = tabela.comparaMenor(tabela,elemento,chave); + } + + + } + */ + + private boolean isCommand(String elemento){ + if(elemento == null){ + return true; + } + else if(elemento.equals("where")){ + return true; + } + else if(elemento.equals("order")){ + return true; + } + else if(elemento.equals("on")){ + return true; + } + else if(elemento.equals("from")){ + return true; + } + else{return false;} + } + + + + private boolean executaWhere(String elemento){ + if(whereList.get(1).contains("=")){ + if(elemento.equals(this.whereList.get(2))){ //IGUAL + return true;} + } + else if(whereList.get(1).contains("!=")){ + if(!elemento.equals(this.whereList.get(2))){ //DIFERENTE + return true;} + } + else if(whereList.get(1).contains(">")){ + if(elemento.compareTo(this.whereList.get(2))>0){ //MAIOR + return true;} + } + else if(whereList.get(1).contains("<")){ + if(elemento.compareTo(this.whereList.get(2))<0){ //MENOR + return true;} + } + else{return false;} + + //boolean resultado = comparaWhere(); + + return false; + } + + private boolean comparaWhere(String elemento){ + if(whereList.get(1).contains("=")){ + if(elemento.equals(this.whereList.get(2))){ //IGUAL + return true;} + } + else if(whereList.get(1).contains("!=")){ + if(!elemento.equals(this.whereList.get(2))){ //DIFERENTE + return true;} + } + else if(whereList.get(1).contains(">")){ + if(elemento.compareTo(this.whereList.get(2))>0){ //MAIOR + return true;} + } + else if(whereList.get(1).contains("<")){ + if(elemento.compareTo(this.whereList.get(2))<0){ //MENOR + return true;} + } + else{return false;} + return false; + } +} diff --git a/java/Tabela.java b/java/Tabela.java new file mode 100644 index 0000000..e403911 --- /dev/null +++ b/java/Tabela.java @@ -0,0 +1,197 @@ +/* + * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license + * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template + */ +package trabalhobd; + + +import java.util.ArrayList; +import java.util.List; + +/* + * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license + * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template + */ + +/** + * + * @author julioc7r + */ +public class Tabela { + + String nomeTabela; + + int tamanho; + + private final int linhas; + private final int colunas; + private List elementos; // mudar para qualquer tipo de variavel + + + public Tabela(String nomeTabela,int linhas, int colunas) { + this.nomeTabela = nomeTabela; + this.tamanho = 0; + this.linhas = linhas; + this.colunas = colunas; + elementos = new ArrayList<>(linhas * colunas); + } + + public int getTamanho() { + return tamanho; + } + + public void setTamanho(Integer tamanho) { + this.tamanho = tamanho; + } + + public int getColunas() { + return colunas; + } + + public int getLinhas() { + return linhas; + } + + public String getNomeTabela() { + return nomeTabela; + } + + public void setNomeTabela(String nomeTabela) { + this.nomeTabela = nomeTabela; + } + + public String getElemento(int posicao) { + return elementos.get(posicao); + } + + public void projecao(String elemento){ + + if(elemento.compareTo("*")==0){ + printTabela(); + } + else{ + int i = 0; + while(i < colunas){ + System.out.println(i + " - "+ elemento + "=" + elementos.get(i)); + if(elemento.compareTo(elementos.get(i))==0){ + break; + } + i++; + } + if(i == colunas){ + System.out.println(" não foi encontrado "); + return;} + else{ + printTabelaColuna(i); + } + } + } + + public int getColunaPeloNome(String elemento){ + int i = 0; + while(i < colunas){ + System.out.println(i + " - "+ elemento + "=" + elementos.get(i)); + if(elemento.compareTo(elementos.get(i))==0){ + return i; + } + i++; + } + return 99; + } + + /* + public String get(int linha, int coluna) { + if (!posicaoValida(linha, coluna)) throw new IllegalArgumentException(); + return elementos.get(posicaoNaLista(linha, coluna)); + }*/ + + public void adicionaElemento(String[] elemento) { + for(int i = 0; i tabelaResultado, int tcolunas, int tlinhas) { // IMPLEMENTAR O MERGE SORT + int tam = 0; + System.out.println(" --------------------------------------------------------------"); + for(int i = 0; i < tlinhas ; i++){ + + for(int j = 0; j comparaIgual(List tabela,String elemento,String chave){ + int n_elementos = selectFila.length; + int n_linhas = this.linhas; + List tabelaResultado = new ArrayList<>(n_elementos*n_linhas); + return tabela; + } + public List comparaDiferente(List tabela,String elemento,String chave){ + return tabela; + } + public List comparaMaior(List tabela,String elemento,String chave){ + return tabela; + } + public boolean comparaMenor(List tabela,String elemento,String chave){ + return false; + }*/ + +} diff --git a/java/TrabalhoBD.java b/java/TrabalhoBD.java new file mode 100644 index 0000000..19e95df --- /dev/null +++ b/java/TrabalhoBD.java @@ -0,0 +1,237 @@ +/* + * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license + * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Main.java to edit this template + */ +package trabalhobd; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; +import java.util.Arrays; +import java.util.LinkedList; +import java.util.Queue; +import java.util.Scanner; + +/** + * + * @author julioc7r + */ +public class TrabalhoBD { + + /** + * @param args the command line arguments + */ + public static void main(String[] args) throws FileNotFoundException, IOException { + + // String[] ma = new String[1]; + Scanner input = new Scanner(System.in); + + // EscolheArquivo tela1 = new EscolheArquivo(); Tentativa de fazer pela + // interface gráfica + + BancoDeDados Banco = new BancoDeDados(); // Cria um Banco de Dados + + System.out.println("Digite o local onde está o arquivo?"); // TESTE /Users/julioc7r/testecsv + String caminhoArquivo = "/Users/julioc7r/testecsv";// input.nextLine(); // Fazer a busca por um + // repositório************ + + File arquivoCSV = new File(caminhoArquivo); + File[] lista_arquivosCSV = arquivoCSV.listFiles(); + System.out.println("Digite o local onde está o arquivo?" + lista_arquivosCSV.length + + Arrays.toString(arquivoCSV.listFiles())); + if (arquivoCSV.exists() == false) { + System.out.println("Arquivo não encontrado/Verifique novamento o caminho"); + return; + } + int n_tabelas = 0; + for (int t = 0; t < lista_arquivosCSV.length; t++) { + if (lista_arquivosCSV[t].getName().contains(".csv")) { + BufferedReader br = new BufferedReader(new FileReader(lista_arquivosCSV[t])); + + int qtd_linhas; + String line = "not null"; + for (qtd_linhas = -1; line != null; qtd_linhas++) {// conta quantas linhas tem o arquivo + line = br.readLine(); + } + // overwrite old buffered reader/ reseta o arquivo para a primeira posição + br = new BufferedReader(new FileReader(lista_arquivosCSV[t])); + + line = br.readLine(); + + String fator_divisor = ","; + if (line.contains(",") == true) { + fator_divisor = ","; + } else if (line.contains(";") == true) { + fator_divisor = ";"; + } + + String[] vect = line.split(fator_divisor); // Divide pela as colunas da tabela + String primeiroHeader = vect[0]; + + System.out.println( + "nome:" + lista_arquivosCSV[t].getName() + " linhas:" + qtd_linhas + " colunas:" + vect.length); + Banco.lista_tabelas + .add(new Tabela(lista_arquivosCSV[t].getName().replace(".csv", ""), qtd_linhas, vect.length)); + + Banco.setN_tabelas(n_tabelas);// atualiza o numero de tabelas no banco + + // Banco.lista_tabelas.get(t).toString(); + // System.out.println(Banco.lista_tabelas.get(t).toString()); + + while (line != null) { + System.out.println(line); + + vect = line.split(fator_divisor); // divide no vetor apartir da virgula + if (vect[0].equals(primeiroHeader)) { + for (int i = 0; i < vect.length; i++) { + vect[i].toLowerCase();// NAOFUNCINOANSdkm + } + } + Banco.lista_tabelas.get(n_tabelas).adicionaElemento(vect); + line = br.readLine(); + } + + System.out.println("Tabela:"); + Banco.lista_tabelas.get(n_tabelas).printTabela(); + n_tabelas++; + + } + } + int opção = 0; + String pesquisa; + char confirma = 'N'; + String elemento; + + do { + System.out.println("TABELAS:"); + for (int i = 0; i < Banco.getN_tabelas(); i++) { + System.out.println("nome:" + Banco.lista_tabelas.get(i).toString()); + } + System.out.println("Bem-vindo!"); + System.out.println("=========="); + System.out.println("1 - Query"); + System.out.println("9 - Sair"); + System.out.println(":"); + opção = input.nextInt(); + + switch (opção) { + case 1: + System.out.println("\nDIGITE A SQL QUEUE"); + elemento = input.nextLine(); + elemento = input.nextLine(); + + String[] vect = elemento.split(" "); + + Queue query = new LinkedList(); + int orderBy = 0; // Flag para se possuir o orderby + + // QUEUE TEST 1 | select emp_no birth_date from employees where // FUNCIONA + // QUEUE TEST 2 | select first_name gender from employees1000 order by gender // + // FUNCIONA + + // CAMINHOTESTE /Users/julioc7r/testecsv + + // emp_no,birth_date,first_name,last_name,gender,hire_date + + for (int i = 0; i < vect.length; i++) { // coloca tudo em letra minuscula e retira a virgula e o + System.out.println(vect[i]); // ponto e virgula que fica na hora que a string é dividida no + // vetor vect[]. + vect[i].toLowerCase(); + + if (vect[i].contains(",")) { + vect[i].replace(",", ""); + } + if (vect[i].contains(";")) { + vect[i].replace(";", ""); + } + query.add(vect[i]); // Adiciona na fila Query + } + + Banco.executaSQL(query); + /* + * + * for(int i = 0 ; i < vect.length ;i ++) + * { + * System.out.println("entrei"+ i); + * if(i == 0 && vect[i].equals("select")){ + * i++; + * query.poll(); + * int j = 1; + * while(vect[i].equals("from")== false){//conta elementos do SELECT + * i++; + * j++; + * } + * i--; + * selectList = new String[j]; + * j = 0; + * do{ + * System.out.println(vect[j+1]+" - "+selectList[j]+j); + * //selectList[j] = vect[j+1]; + * selectList[j] = query.poll(); + * System.out.println(vect[j+1]+" - "+selectList[j]+j); + * j++; + * }while(vect[j+1].equals("from")== false); + * } + * + * if(vect[i].equals("from")){ + * //i++; + * int j = 0; + * while((vect[i+1].equals("where")== false)){//||(vect[i+1].equals("order")== + * false)){//conta elementos do SELECT + * i++; + * j++; + * System.out.println("entrei"+ i + j); + * } + * i-=j-1; + * fromList = new String[j]; + * j = 0; + * do{ + * System.out.println(vect[i]+" - "+fromList[j]+j); + * fromList[j] = vect[i]; + * System.out.println(vect[i]+" - "+fromList[j]+j+"i "+i); + * j++; + * i++; + * }while((vect[i].equals("where")== false));//||(vect[i].equals("order")== + * false)); + * } + * + * if(vect[i].equals("order") && vect[i+1].equals("by")){ + * orderBy=1; + * i = i + 2; + * System.out.println("oi"+i); + * int k; // posição do atributo que vai ser usado para ordenar a tabela no + * selectList + * if(vect[i].equals(selectList[0])== false){ + * for(k = 1; k < selectList.length; k++){ + * if(vect[i].equals(selectList[k])) + * break; + * } + * String swap = selectList[0]; + * selectList[0] = selectList [k]; + * selectList[k] = swap; + * System.out.println("oi"); + * } + * } + * + * } + * + * int i; + * + * Tabela t = lista_tabelas.get(0); + * t.resultadoQuery(selectList,orderBy); + */ + + case 9: + System.out.println("Tem certeza que deseja sair?(S)para sair"); + confirma = input.next().toUpperCase().charAt(0); + break; + + } + } while (confirma != 'S'); + + input.close(); + } + +} diff --git a/java/sourcecsv/teste.csv b/java/sourcecsv/teste.csv new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/java/sourcecsv/teste.csv @@ -0,0 +1 @@ + diff --git a/main.py b/main.py new file mode 100644 index 0000000..32d1d72 --- /dev/null +++ b/main.py @@ -0,0 +1,36 @@ +import os + +from table import Table +from sql import SQL + +def main(): + print("Bem vindo ao SGBD") + print("Digite a pasta onde está os arquivos CSV:") + #csv_folder = input() + csv_folder = "/mnt/c/Users/jose/Desktop/jcSQL-main/source" + + tables = {} + + # get all csv files in the folder + for file in os.listdir(csv_folder): + if file.endswith(".csv"): + table_name = file.split(".")[0] + table = Table(table_name) + table.load_from_csv(f"{csv_folder}/{file}") + tables[table_name] = table + + print("Tabelas carregadas:") + print(tables.keys()) + + while True: + print("Digite a query [0 para sair]:") + query = input() + + if query == "0": + break + + sql = SQL(tables, query) + sql.execute() + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/source/city.csv b/source/city.csv new file mode 100644 index 0000000..1418fca --- /dev/null +++ b/source/city.csv @@ -0,0 +1,4 @@ +city,state,country +London,England,United Kingdom +Kansas City,Kansas,United States +Rio de Janeiro,Rio de Janeiro,Brazil \ No newline at end of file diff --git a/source/person.csv b/source/person.csv new file mode 100644 index 0000000..90da7ad --- /dev/null +++ b/source/person.csv @@ -0,0 +1,4 @@ +name,surname,age,city +Bob,Smith,32,London +Angelina,Jolie,90,Kansas City +Wellerton,Abigail,4,Rio de Janeiro \ No newline at end of file diff --git a/sql.py b/sql.py new file mode 100644 index 0000000..4d278bb --- /dev/null +++ b/sql.py @@ -0,0 +1,41 @@ +from table import Table + +class SQL: + def __init__(self, tables: dict, query: str) -> None: + self.tables = tables + self.query = query.replace(";", "") + + def __str__(self) -> str: + pass + + # SELECIONAR * DE tabela + def execute(self): + query_parts = self.query.split(" ") + + if query_parts[0] == "SELECIONAR": + self.select(query_parts) + else: + pass + + # SELECIONAR * DE tabela ONDE coluna = valor JUNTAR tabela2 coluna + def select(self, query_parts: list) -> None: + where_filter = None + join_stmt = None + + if "ONDE" in query_parts: + index = query_parts.index("ONDE") + where_filter_column = query_parts[index + 1] + where_filter_operator = query_parts[index + 2] + where_filter_value = query_parts[index + 3] + where_filter = [where_filter_column, where_filter_operator, where_filter_value] + + if "JUNTAR" in query_parts: + index = query_parts.index("JUNTAR") + join_table = query_parts[index + 1] + join_column = query_parts[index + 2] + join_stmt = [self.tables[join_table], join_column] + + table = self.tables[query_parts[3]] + table.print_columns(table.columns, + where_filter=where_filter, + join_stmt=join_stmt) diff --git a/table.py b/table.py new file mode 100644 index 0000000..610bec9 --- /dev/null +++ b/table.py @@ -0,0 +1,52 @@ +class Table: + def __init__(self, name): + self.name = name + self.columns = [] + self.rows = [] + + def __str__(self): + return self.name + + def __repr__(self): + return self.name + + def load_from_csv(self, csv_file): + with open(csv_file, 'r') as f: + reader = f.read().splitlines() + + # First line is the column names + self.columns = reader[0].split(',') + reader.pop(0) + + for row in reader: + row = row.split(',') + self.rows.append(row) + + def print_columns(self, column_list: list, where_filter: list = None, join_stmt: list = None): + if column_list[0] == '*': + column_list = self.columns + + print(', '.join(column_list)) + print('-' * 20) + + for row in self.rows: + if where_filter is not None: + column_index = self.columns.index(where_filter[0]) + row_value = row[column_index] + + if where_filter[1] == '=': + if row_value != where_filter[2]: + continue + elif where_filter[1] == '>': + if row_value <= where_filter[2]: + continue + elif where_filter[1] == '<': + if row_value >= where_filter[2]: + continue + + row_values = [] + for column in column_list: + column_index = self.columns.index(column) + row_values.append(row[column_index]) + + print(', '.join(row_values))