Mini SGBD[Resolvido]

26 de novembro de 2010 12 respostas

Balena 26 de novembro de 2010

Como trabalho da faculdade, tenho que desenvolver um mini sgbd. As colunas das tabelas devem ser variáveis bem como o tamanho da mesma. Isto não é muito difícil de fazer, meu problema é que tenho que passar como parâmetro da o tipo de dados que minha coluna vai armazenar, e isto não está funcionando adequadamente. Estou utilizando como tipo genérico o Class, mas já tentei usar T, nos dois casos não fui muito longe.

public class Tabela {

    private ArrayList&lt;ArrayList&gt;&lt;Class&gt;&gt; colunas;
    private String[] nomeColunas;
    private int i;

    public Tabela(){
        i = 0;
        colunas = new ArrayList&lt;ArrayList&gt;&lt;Class&gt;&gt;();
        nomeColunas = new String[5];
    }

    public void adicionaColuna(Class tipo, String nomeColuna){
        ArrayList&lt;Class&gt; lista = new ArrayList&lt;Class&gt;();
        colunas.add(lista);
        nomeColunas[i] = nomeColuna;
        i++;
    }
    
    public void adicionaDado(Class dado){
        int j = 0;
        colunas.get(j).add(dado);
        System.out.println(colunas.get(j).get(j));
    }

    public ArrayList getColunas() {
        return colunas;
    }

    public String[] getNomeColunas() {
        return nomeColunas;
    }
}

Esse aí é como está o código atualmente, não tem muita coisa, empaquei mesmo na hora de tipar o meu array
se alguém tiver uma idéia, um código pra dar uma olhada tudo é bem vindo.

12 Respostas

aluisiodsv 26 de nov. de 2010

Usa o Object .

Balena 26 de nov. de 2010

Class, Object e T é tudo a mesma coisa.

Outra idéia?

aluisiodsv 26 de nov. de 2010

package org.domain.teste.session;

import java.util.HashMap;
import java.util.Map;

public class Table {

	private String name;
	private Map&lt;String, Object&gt; columns;

	public Table(String name) {
		this.name = name;
		columns = new HashMap&lt;String, Object&gt;();
	}

	public void addColumn(String name, Object type) {
		if (name != null && type != null) {
			if (!columns.containsKey(name)) {
				columns.put(name, type);
				System.out.println("Coluna " + name + " adicionada com sucesso!");
			} else {
				System.out.println("# Coluna não adicionada");
				System.out.println("# Já existe uma coluna com o nome " + name);
			}
		}
	}

	public void removeColumn(String name) {
		if (name != null) {
			if (columns.containsKey(name)) {
				columns.remove(name);
				System.out.println("Coluna " + name + " removida com sucesso!");
			} else {
				System.out.println("# Coluna não removida");
				System.out.println("# Não existe uma coluna com o nome " + name);
			}
		}
	}

	public void alterColumn(String name, Object type) {
		if (name != null && type != null) {
			if (columns.containsKey(name)) {
				columns.put(name, type);
				System.out.println("Coluna " + name + " alterada com sucesso!");
			} else {
				System.out.println("# Coluna não alterada");
				System.out.println("# Não existe uma coluna com o nome " + name);
			}
		}
	}

	public Object getTypeColumn (String name) {
		return columns.get(name);
	}

	public Map&lt;String, Object&gt; getColumns() {
		return columns;
	}
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

}

Tá pronto a parte superficial … e é uma idéia, pode não ser a melhor.
Qndo eu tiver mais tempo faço a parte dos dados, para q sejam tipados.

aluisiodsv 26 de nov. de 2010

Eita. Esqueci de colocar os comentários para explicar melhor …
Estou meio sem tempo.

Balena 26 de nov. de 2010

cara eu até entendi…
o problema é como é que eu preciso adicionar os dados, e verificar tipagem…
não entendi como eu vou fazer isso usando Object

aluisiodsv 26 de nov. de 2010

Ao adicionar uma nova coluna em coluns vc passa o nome do campo e o tipo.
Por exemplo, usando o método:

addColumn("id", Integer);
addColumn("nome", String);

aí no código onde vai ser adicionado os valores ficaria mais ou menos assim:

// Parte em q adiciona na coluna id
if (id instanceof columns.get("id")) {
    dados.add(id);
}

É claro q o q eu coloquei aí é só pra exemplificar minha idéia.
No código isso vai ficar variável, pois vc pode adicionar quantas colunas quiser.

aluisiodsv 26 de nov. de 2010

AUHUAuHAUHU … tá pronto!
Quem vê pensa q eu não trabalho…

Realmente tinha razão sobre o Object. Tinha q ser Class.

package org.domain.teste.session;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public class Table {

	private String name;
	private Map&lt;String, Class&gt; columns;
	private List&lt;List&lt;Object&gt;&gt; data;

	public Table(String name) {
		this.name = name;
		columns = new LinkedHashMap&lt;String, Class&gt;();
		setData(new ArrayList&lt;List&lt;Object&gt;&gt;());
	}

	public void addNewRow(Object... type) {
		// Verifica se a quantidade de objetos passados é igual a quantidade de
		// colunas
		int count = 0;
		for (Object o : type)
			count++;

		if (count != columns.size())
			System.out.println("# Quantidade de objetos passados não confere com a quantidade de colunas da tabela");

		// Verifica os tipos e adiciona os dados na lista
		List&lt;Object&gt; row = new ArrayList&lt;Object&gt;();
		List&lt;Class&gt; types = new ArrayList&lt;Class&gt;(columns.values());
		int i = 0;
		for (Object o : type) {
			if (types.get(i).equals(o.getClass())) {
				row.add(o);
				i++;
			} else {
				row.clear();
				System.out.println("# Registro não adicionado");
				System.out.println("# " + o + " não é do tipo " + types.get(i).getClass());
				break;
			}
		}

		// Verifica se todos os dados foram adicionados
		if (row.size() != count) {
			System.out.println("# Ocorreu algum erro ao adicionar os dados :(");
		}

		// Por fim adiciona esta linha na tabela
		data.add(row);
	}

	public void dataList() {
		for (List&lt;Object&gt; row : data) {
			String rowString = "[";
			for (Object o : row) {
				rowString += o + ",";
			}
			rowString += "]";
			System.out.println(rowString);
		}
	}

	public void addColumn(String name, Class clazz) {
		if (name != null && clazz != null) {
			if (!columns.containsKey(name)) {
				columns.put(name, clazz);
				System.out.println("Coluna " + name + " adicionada com sucesso!");
			} else {
				System.out.println("# Coluna não adicionada");
				System.out.println("# Já existe uma coluna com o nome " + name);
			}
		}
	}

	public void removeColumn(String name) {
		if (name != null) {
			if (columns.containsKey(name)) {
				columns.remove(name);
				System.out.println("Coluna " + name + " removida com sucesso!");
			} else {
				System.out.println("# Coluna não removida");
				System.out.println("# Não existe uma coluna com o nome " + name);
			}
		}
	}

	public void alterColumn(String name, Class clazz) {
		if (name != null && clazz != null) {
			if (columns.containsKey(name)) {
				columns.put(name, clazz);
				System.out.println("Coluna " + name + " alterada com sucesso!");
			} else {
				System.out.println("# Coluna não alterada");
				System.out.println("# Não existe uma coluna com o nome " + name);
			}
		}
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Object getTypeColumn(String name) {
		return columns.get(name);
	}

	public Map&lt;String, Class&gt; getColumns() {
		return columns;
	}

	public void setData(List&lt;List&lt;Object&gt;&gt; data) {
		this.data = data;
	}

	public List&lt;List&lt;Object&gt;&gt; getData() {
		return data;
	}

}

package org.domain.teste.session;

public class Teste {

	public static void main(String[] args) {
		
		// Nova tabela
		Table table = new Table("cliente");
		
		// Adicionar as colunas da tabela
		table.addColumn("id", Integer.class);
		table.addColumn("name", String.class);
		table.addColumn("single", Boolean.class);
		
		// Adicionar dados *
		table.addNewRow(1, "Aluisio", true);
		table.addNewRow(1, "Teste", false);
		table.addNewRow(3, "Outro teste", false);
		
		table.dataList();
	}

}

Quero meus créditos hein ?!

Balena 28 de nov. de 2010

Caramba muito bom…
cheguei em algo bem parecido…
agora estou mechendo com o remove…
que no meu caso tem que ser feito de forma arbitrária, acessando o arquivo…
mas to quase lá já…
quando estiver pronto eu posto o código aqui pra você dar uma olhada…
mas ficou fera esse que vc fez aí…
muito bom mesmo…

Obrigado pela ajuda…
Foi bem esclarecedor…

Balena 29 de nov. de 2010

Um pouco complexo mas como prometi, essa é a solução que conseguimos chegar por aqui…

Agradecimento ao aluisiodsv por ter esclarecido algumas dúvidas, e por ter se empenhado tanto em ajudar com uma solução proópria.

meu código segue:

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.HashMap;

/**
 *
 * @author Balena
 */
public class GravaArquivo {

    private HashMap&lt;Object, Integer&gt; hashBanco;
    private ArrayList&lt;Integer&gt; emUso;
    private File f;
    private File hash;
    private BufferedInputStream bInStream;
    private BufferedOutputStream bOutStream;
    private FileOutputStream fOutStream;
    private FileInputStream fInStream;
    private ObjectOutputStream outStream;
    private ObjectInputStream inStream;
    private DataInputStream dInStream;
    private DataOutputStream dOutStream;
    private int indiceArquivo;

    public GravaArquivo(){
        f = new File("BalenaDB");
        hash = new File("HashDB");
        indiceArquivo = 0;
    }

    public void addData(ArrayList&lt;Object&gt; data) throws Exception{
        fOutStream = new FileOutputStream(f, true);
        outStream = new ObjectOutputStream(fOutStream);

        if (fOutStream == null){
            throw (new Exception("Arquivo não existe"));
        }

        if (outStream == null){
            throw (new Exception("Arquivo não existe, ou existem instancias já abertas"));
        }

        outStream.writeObject(data);
        //hashBanco.put(data.getIndiceChave(), i);
        outStream.close();
        fOutStream.close();
    }

    public ArrayList&lt;Object&gt; getLinha(Object chave) throws Exception{
        indiceArquivo = hashBanco.get(chave);
        fInStream = new FileInputStream(f);
        bInStream = new BufferedInputStream(fInStream);
        inStream = new ObjectInputStream(bInStream);

        if (fInStream == null){
            throw new Exception("Este arquivo não existe");
        }
        if (inStream == null){
            throw new Exception("Arquivo em uso");
        }
        ArrayList&lt;Object&gt; linha = new ArrayList&lt;Object&gt;();
        for(int j = 0; j &lt;= indiceArquivo; j++){
            if (emUso.contains(j)) {
                linha = (ArrayList&lt;Object&gt;) inStream.readObject();
                inStream = new ObjectInputStream(bInStream);
            }
        }
        return linha;
    }

    public void deleteLine(Object chave) throws Exception{
        Integer indice;
        indice = hashBanco.get(chave);
        hashBanco.remove(chave);
        emUso.remove(indice);
    }

    public void gravaNaHash(Object chave){
        hashBanco.put(chave, indiceArquivo);
        indiceArquivo++;
        emUso.add(indiceArquivo);
    }

    public void writeData(ArrayList&lt;Class&gt; colunas, ArrayList&lt;String&gt; nomeColunas) throws Exception{
        fOutStream = new FileOutputStream(hash, true);
        bOutStream = new BufferedOutputStream(fOutStream);
        outStream = new ObjectOutputStream(bOutStream);

        outStream.writeObject(hashBanco);
        outStream.writeObject(emUso);
        outStream.writeObject(colunas);
        outStream.writeObject(nomeColunas);

        outStream.close();
        bOutStream.close();
        fOutStream.close();
    }

    public ArrayList readColumns() throws Exception{
        fInStream = new FileInputStream(hash);
        bInStream = new BufferedInputStream(fInStream);
        inStream = new ObjectInputStream(bInStream);

        if (fInStream == null){
            throw new Exception("Este arquivo não existe");
        }
        if (inStream == null){
            throw new Exception("Arquivo em uso");
        }
        hashBanco = (HashMap) inStream.readObject();
        inStream = new ObjectInputStream(bInStream);
        emUso = (ArrayList) inStream.readObject();
        inStream = new ObjectInputStream(bInStream);
        return (ArrayList) inStream.readObject();
    }

    public ArrayList readNameColumns() throws Exception{
        fInStream = new FileInputStream(hash);
        bInStream = new BufferedInputStream(fInStream);
        inStream = new ObjectInputStream(bInStream);

        if (fInStream == null){
            throw new Exception("Este arquivo não existe");
        }
        if (inStream == null){
            throw new Exception("Arquivo em uso");
        }
        for (int i = 0; i &lt; 3; i++){
            inStream = new ObjectInputStream(bInStream);
        }
        return (ArrayList) inStream.readObject();
    }
}



import java.io.Serializable;
import java.util.ArrayList;


/**
 *
 * @author Balena
 */
public class Tabela implements Serializable {

    ArrayList&lt;Class&gt; colunas;
    ArrayList&lt;String&gt; nomeColunas;
    ArrayList&lt;Object&gt; linha;
    GravaArquivo g;
    int indiceChave;
    int numColunas;
    
    public Tabela(){
        g = new GravaArquivo();
        this.colunas = leColunas();
        this.nomeColunas = leNomeColunas();
        numColunas = 0;
    }

    public void adicionarColuna(Class classe, String nome){
        colunas.add(classe);
        nomeColunas.add(nome);
        numColunas++;
    }

    public void addDataColumn(Class type, Object data) throws Exception, NullPointerException{
        if (linha == null){
            linha = new ArrayList&lt;Object&gt;();
        }
        if (type.toString().equals(data.getClass().toString())){
            linha.add(data);
        }else{
            throw new Exception("Tipos inconsistentes de dados");
        }
    }

    public void addLine(ArrayList&lt;Object&gt; linha){
        int i = 0;
        for (Object o : linha){
            if ((o.getClass().equals(colunas.get(i)))){
                this.linha.add(o);
            }
        }
        try{
            g.addData(linha);
            g.gravaNaHash(linha.get(indiceChave));
        } catch (Exception ex) {
            System.out.println(ex.toString());
        }
    }

    public void deleteLine(Object chave){
        if (chave.getClass().equals(colunas.get(indiceChave))){
            try {
                g.deleteLine(chave);
            } catch (Exception ex) {
                System.out.println(ex.toString());
            }
        }
    }

    public void printLine(){
        for (Object o : linha){
            System.out.println(o.toString() + " Tipo: " + o.getClass());
        }
    }

    public void setKey(String nomeCampo){
        int aux = 0;
        for (int i = 0; i &lt; nomeColunas.size(); i++){
            if (nomeColunas.get(i).equals(nomeCampo)){
                aux = i;
            }
        }
        indiceChave = aux;
    }

    public void gravaColunas(){
        try{
            g.writeData(colunas, nomeColunas);
        }catch (Exception ex){
            System.out.println(ex.toString());
        }
    }

    public final ArrayList leColunas(){
        ArrayList&lt;Class&gt; colunas = new ArrayList&lt;Class&gt;();
        try{
            colunas = g.readColumns();
        }catch (Exception ex){
            System.out.println(ex.toString());
        }
        return colunas;
    }

    public final ArrayList leNomeColunas(){
        ArrayList&lt;String&gt; nomeColunas = new ArrayList&lt;String&gt;();
        try{
            nomeColunas = g.readNameColumns();
        }catch(Exception ex){
            System.out.println(ex.toString());
        }
        return nomeColunas;
    }

    public ArrayList&lt;Class&gt; getColunas() {
        return colunas;
    }

    public int getIndiceChave() {
        return indiceChave;
    }
}



public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Tabela t = new Tabela();
        t.adicionarColuna(Integer.class, "id");
        t.adicionarColuna(String.class, "nome");
        try{
            t.addDataColumn(Integer.class, 1);
            t.addDataColumn(String.class, "Lucas");
        }catch(Exception ex){
            System.out.println(ex.toString());
        }
        t.printLine();

        ArrayList&lt;Object&gt; linha = new ArrayList&lt;Object&gt;();
        linha.add(2);
        linha.add("Balena");

        t.addLine(linha);

    }

}

Mas ainda está dando um errinho…
que eu vou ter qeu descobrir, porque é que ele não consegue criar o arquivo hashDB…

aluisiodsv 29 de nov. de 2010

AUHUAhuuAhAUH … ficou legal.
Dá pra brincar muito com um negócio desses.

Balena 1 de dez. de 2010

sim com certeza.

aluisiodsv 1 de dez. de 2010

Obs: Corrigi alguns errinhos q tinha. Ao passar o código aqui ele mudou um negócio lá:

era assim List<List><…>>
ele pois assim List<List><…>>

arrumei já.

Criado 26 de novembro de 2010

Ultima resposta 1 de dez. de 2010

Respostas 12

Participantes 2

12 Respostas

Topicos relacionados