Olá como viram no titulo o SQL fica dando esse erro. O app nao da crash e carrega as
informaçoes normalmente mais no terminal eu fico vendo esse erro. Abaixo esta o CRUD.
CREATE: cria as tabelas se elas nao existirem
package CRUD;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
public class Create extends SQLiteOpenHelper {
private static final String NOME_BASE = DB_Names.NOME_BASE;
private static final int VERSAO_BASE = DB_Names.VERSAO_BASE;
private static final String FOLHAS_TABLE = DB_Names.FOLHAS_TABLE;
private static final String DEBITOS_TABLE = DB_Names.DEBITOS_TABLE;
private static final String DEBITOFIXO_TABLE = DB_Names.DEBITOFIXO_TABLE;
private static final String CONFIGURAÇAO_TABLE = DB_Names.CONFIGURAÇAO_TABLE;
private static Create instancia = null;
public static Create getInstancia(Context context) {
if (instancia == null) {
instancia = new Create(context);
}
return instancia;
}
private Create(Context context) {
//toda vez que essa classe é instanciada ela checa se as tabelas exitem e as cria se necessario
super(context, NOME_BASE, null, VERSAO_BASE);
}
@Override
public void onCreate(SQLiteDatabase db) {
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
}
/**
* Cria a tabela de debitos fixos
*/
public void createDebitoFixoTable() {
SQLiteDatabase db = getWritableDatabase();
String SQLCreateTabelaFdebito = "CREATE TABLE IF NOT EXISTS " + DEBITOFIXO_TABLE + "("
+ "ID TEXT,"
+ "VALOR TEXT,"
+ "DATA TEXT,"
+ "OBSERVACAO TEXT,"
+ "QUITADO INTEGER,"
+ "FIXO INTEGER,"
+ "FOLHA TEXT,"
+ "CATEGORIA TEXT,"
+ "N_ID TEXT"
+ ")";
db.execSQL(SQLCreateTabelaFdebito);
db.close();
}
/**
* Cria a tabela de debitos fixos
*/
public void createDebitosTable() {
SQLiteDatabase db = getWritableDatabase();
String SQLCreateTabelaFdebito = "CREATE TABLE IF NOT EXISTS " + DEBITOS_TABLE + "("
+ "ID TEXT,"
+ "VALOR TEXT,"
+ "DATA TEXT,"
+ "OBSERVACAO TEXT,"
+ "QUITADO INTEGER,"
+ "FIXO INTEGER,"
+ "FOLHA TEXT,"
+ "CATEGORIA TEXT,"
+ "N_ID TEXT"
+ ")";
db.execSQL(SQLCreateTabelaFdebito);
db.close();
System.out.println("Create.createDebitosTable");
}
public void createFolhasTabela() {
SQLiteDatabase db = getWritableDatabase();
String SQLCreateTabelaFdebito = "CREATE TABLE IF NOT EXISTS " + FOLHAS_TABLE + "("
+ "NOME_FOLHA TEXT,"
+ "MES_FOLHA TEXT,"
+ "RENDA_FOLHA TEXT"
+ ")";
db.execSQL(SQLCreateTabelaFdebito);
db.close();
}
/**
* Cria a tabela de FOLHAS
*/
public void createCOnfTable() {
SQLiteDatabase db = getWritableDatabase();
String sqlCreateTabelaLivro = "CREATE TABLE IF NOT EXISTS " + CONFIGURAÇAO_TABLE + "("
+ "ID INTEGER,"
+ "CONFVAL TEXT"
+ ")";
db.execSQL(sqlCreateTabelaLivro);
db.close();
}
}
DB_Names: contem as constatantes do database
package CRUD;
/**
* Created by Gilian Marques on 11/11/2016.
*/
public class DB_Names {
private static DB_Names instancia = null;
public static DB_Names getInstancia() {
if (instancia == null) {
instancia = new DB_Names();
}
return instancia;
}
public static final String NOME_BASE = "DRDB";
public static final int VERSAO_BASE = 1;
public static final int CONF_ID = 1;
public static final String FOLHAS_TABLE = "FOLHAS";
public static final String DEBITOFIXO_TABLE = "DEBITOS_FIXOS";
public static final String DEBITOS_TABLE = "DEBITOS";
public static final String CONFIGURAÇAO_TABLE = "CONFIGURACOES";
}
DELETE : apaga os dados das tabelas
package CRUD;
import android.content.ContentValues;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import objetos.debito;
objetos.folha;
public class Delete extends SQLiteOpenHelper {
private static final String NOME_BASE = DB_Names.NOME_BASE;
private static final int VERSAO_BASE= DB_Names.VERSAO_BASE;
private static final String FOLHAS_TABLE = DB_Names.FOLHAS_TABLE; private static final String DEBITOS_TABLE = DB_Names.DEBITOS_TABLE;
private static final String DEBITOFIXO_TABLE= DB_Names.DEBITOFIXO_TABLE;
private static Delete instancia = null;
public static Delete getInstancia(Context context) {
if (instancia == null) {
instancia = new Delete(context);
}
return instancia;
}
private Delete(Context context) {
//toda vez que essa classe é instanciada ela checa se as tabelas exitem e as cria se necessario
super(context, NOME_BASE, null, VERSAO_BASE);
}
@Override
public void onCreate(SQLiteDatabase db) {
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
}
/**
* remove o debito fixo que bate com a id recebida
*
* @param nome o nome do debito que deve ser removido
* @return TRUE se tudo ocorreu bem, isso n quer dizer que o debito foi removido pois pode ser que o debito
* recebido n exista na tabela e isso nao gera um erro. FALSE se houver algum erro.
*/
public boolean removeDebitoFixo(String nome) {
SQLiteDatabase db = getWritableDatabase();
try {
db.delete(DEBITOFIXO_TABLE, "ID = '" + nome + "'", null);
System.out.println("Create.removeDebitoFixo ddbHelper debito fixo removido " + nome);
return true;
} catch (Exception e) {
e.printStackTrace();
System.out.println("Create.removeDebitoFixo ddbHelper debito fixo NAO removido " + nome);
return false;
} finally {
db.close();
}
}
/**
* remove o debito que bate com a id recebida
*
* @param nome o nome do debito que deve ser removido
* @return TRUE se tudo ocorreu bem. FALSE se houver algum erro.
*/
public boolean removeDebito(String nome, folha f) {
SQLiteDatabase db = getWritableDatabase();
try {
db.delete(DEBITOS_TABLE, "ID = '" + nome + "'", null);
System.out.println("Create.removeDebito ddbHelper debito removido " + nome + " da folha " + f.getIdentificaçao());
return true;
} catch (Exception e) {
e.printStackTrace();
System.out.println("Create.removeDebito ddbHelper debito NAO removido " + nome + " da folha " + f.getIdentificaçao());
return false;
} finally {
db.close();
}
}
/**
* remove a folha do banco de dados: Remove a tabela correspondente a folha
* depois apaga o nome da folha da tabela de nomes
*
* @param nomeFolha o nome que sera usado para localizar a tabela e o registro na
* tabela de nomes
* @return TRUE se tudo ocorreu bem FALSE se houve algum erro
*/
public boolean RemoveFolha(String nomeFolha) {
System.out.println("Create.RemoveFolha");
SQLiteDatabase db = getWritableDatabase();
try {
//removendo tabela
String sqlDropTabelaLivros = "DROP TABLE " + nomeFolha.replace(" ", "_");
db.execSQL(sqlDropTabelaLivros);
//removendo nome da tala de folhas
try {
db.delete(FOLHAS_TABLE, "NOME_FOLHA = '" + nomeFolha + "'", null);
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
db.close();
}
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
db.close();
}
System.out.println("Create.RemoveFolha folha removida " + nomeFolha);
return true;
}
}
READ : obtem os dados do DB
package CRUD;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import java.util.ArrayList;
import main.splashScreen;
import objetos.debito;
import objetos.folha;
public class Read extends SQLiteOpenHelper {
private static final String NOME_BASE = DB_Names.NOME_BASE;
private static final int VERSAO_BASE = DB_Names.VERSAO_BASE;
private static final String FOLHAS_TABLE = DB_Names.FOLHAS_TABLE;
private static final String DEBITOS_TABLE = DB_Names.DEBITOS_TABLE;
private static final String DEBITOFIXO_TABLE = DB_Names.DEBITOFIXO_TABLE;
private static final String CONFIGURAÇAO_TABLE = DB_Names.CONFIGURAÇAO_TABLE;
private static Read instancia = null;
public static Read getInstancia(Context context) {
if (instancia == null) {
instancia = new Read(context);
}
return instancia;
}
private Read(Context context) {
super(splashScreen.context, NOME_BASE, null, VERSAO_BASE);
}
@Override
public void onCreate(SQLiteDatabase db) {
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
}
/**
* obtem a configuraçao atual do app
*
* @return NULL se nao houver configuraçao caso haja, retorna UMA STRING com as configuraçoes
* checa atraves da checagem da primeira configuraçao, se for
* invalida retorna null se for valida retorna a configuraçao (STRING)
*/
public String getConfiguraçao() {
System.out.println("Read.getConfiguraçao");
SQLiteDatabase db = getReadableDatabase();
String SQLgetAllDebios = "SELECT * FROM " + CONFIGURAÇAO_TABLE;
String configuraçoes = null;
Cursor c = db.rawQuery(SQLgetAllDebios, null);
if (c.moveToFirst()) {
configuraçoes = c.getString(1);
}
db.close();
if (configuraçoes.equals("")) {
return null;
}
return configuraçoes;
}
/**
* retorna uym arrayList com todas as folhas (OBJETO) cadastradas no banco de dados
* OS NOMES RETORNADOS SAO DAS FOLHAS E NAO DAS TABELAS
*
* @return null se o tamanho do array for menor ou igual a 0
*/
public ArrayList<folha> getTodasFolhas() {
System.out.println("Read.getTodasFolhas");
ArrayList<folha> array = new ArrayList<>();
SQLiteDatabase db = getReadableDatabase();
String sqlSelectTodosLivros = "SELECT * FROM " + FOLHAS_TABLE + "";
Cursor c = db.rawQuery(sqlSelectTodosLivros, null);
if (c.moveToFirst()) {
do {
folha f = new folha();
f.setIdentificaçao(c.getString(0));
f.setMes(c.getString(1));
f.setRenda(c.getString(2));
array.add(f);
} while (c.moveToNext());
}
db.close();
if (array.size() <= 0) {
return null;
} else {
return array;
}
}
/**
* @param nome a id da folha que sera obtida
* @return a folha que bate com oo nome recebido ou NULL se nao houver essa folha ou em caso de erro
*/
public folha getFolha(String nome) {
System.out.println("Read.getFolha");
ArrayList<folha> array = new ArrayList<>();
SQLiteDatabase db = getReadableDatabase();
String sqlSelectTodosLivros = "SELECT * FROM " + FOLHAS_TABLE + "";
Cursor c = db.rawQuery(sqlSelectTodosLivros, null);
if (c.moveToFirst()) {
do {
if (c.getString(0).equals(nome)) {
folha f = new folha();
f.setIdentificaçao(c.getString(0));
f.setMes(c.getString(1));
f.setRenda(c.getString(2));
db.close();
return f;
}
}
while (c.moveToNext());
}
return null;
}
/**
* poe os debitos da folha recebida num ArrayList e a retorna
*
* @param f
* @return
*/
public void getDebitos(folha f) {
SQLiteDatabase db = getReadableDatabase();
ArrayList<debito> DBDeb = new ArrayList<>();
ArrayList<debito> DBDeb2 = new ArrayList<>();
String SQLgetAllDebios = "SELECT * FROM " + DEBITOS_TABLE;
Cursor c = db.rawQuery(SQLgetAllDebios, null);
int i = 0;
if (c.moveToFirst()) {
do {
if (c.getString(6).equals(f.getIdentificaçao())) {
debito d = new debito();
d.setIdentificaçao(c.getString(0));
d.setValor(c.getString(1));
d.setDataDePagamento(c.getString(2));
d.setObservaçao(c.getString(3));
d.setQuitado(Boolean.parseBoolean(c.getString(4)));
d.setFixo(Boolean.parseBoolean(c.getString(5)));
d.setFolha((c.getString(6))); // 0 ?
d.setCategoria(c.getString(7));
d.setId(c.getString(7));
DBDeb2.add(d);
i++;
}
} while (c.moveToNext());
}
for (int j = DBDeb2.size()-1; j >= 0; j--) {
DBDeb.add(DBDeb2.get(j));
}
System.out.println("Read.getDebitos " + i + " debitos inseridos em " + f.getIdentificaçao());
db.close();
f.setDebitos(DBDeb);
}
/**
* Obtem os debitos fixos registrados no banco de dados
*
* @return todos os debitos fixos em um ArrayList
*/
public ArrayList<debito> getAllDebitosFixos() {
System.out.println("Read.getAllDebitosFixos");
ArrayList<debito> listDebitos = new ArrayList<>();
SQLiteDatabase db = getReadableDatabase();
String SQLgetAllDebios = "SELECT * FROM " + DEBITOFIXO_TABLE;
Cursor c = db.rawQuery(SQLgetAllDebios, null);
if (c.moveToFirst()) {
do {
//checo se a id esta vazia, se n estiver entao prossigo
if (c.getString(1) != null) {
debito d = new debito();
d.setIdentificaçao(c.getString(0));
d.setValor(c.getString(1));
d.setDataDePagamento(c.getString(2));
d.setObservaçao(c.getString(3));
d.setQuitado(Boolean.parseBoolean(c.getString(4)));
d.setFixo(Boolean.parseBoolean(c.getString(5)));
d.setFolha((c.getString(6))); // 0 ?
d.setCategoria(c.getString(7));
d.setId(c.getString(7));
listDebitos.add(d);
}
} while (c.moveToNext());
}
db.close();
return listDebitos;
}
}
UPDATE : inseri novos dados e atualiza os dados ja existentes
package CRUD;
import android.content.ContentValues;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import main.splashScreen;
import objetos.debito;
import objetos.folha;
public class Update extends SQLiteOpenHelper {
private static final String NOME_BASE = DB_Names.NOME_BASE;
private static final int VERSAO_BASE = DB_Names.VERSAO_BASE;
private static final int CONF_ID = DB_Names.CONF_ID;
private static final String DEBITOS_TABLE = DB_Names.DEBITOS_TABLE;
private static final String FOLHAS_TABLE = DB_Names.FOLHAS_TABLE;
private static final String DEBITOFIXO_TABLE = DB_Names.DEBITOFIXO_TABLE;
private static final String CONFIGURAÇAO_TABLE = DB_Names.CONFIGURAÇAO_TABLE;
private static Update instancia = null;
public static Update getInstancia(Context context) {
if (instancia == null) {
instancia = new Update(splashScreen.context);
}
return instancia;
}
private Update(Context context) {
//toda vez que essa classe é instanciada ela checa se as tabelas exitem e as cria se necessario
super(context, NOME_BASE, null, VERSAO_BASE);
}
@Override
public void onCreate(SQLiteDatabase db) {
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
}
/**
* Escreve no banco de dados as configuraçoes contidas em C
*
* @param c a configuraçao atual que sera salva
*/
public boolean setConfiguraçoes(String c) {
System.out.println("Create.setConfiguraçoes");
SQLiteDatabase db = getWritableDatabase();
String where = "ID" + "='" + CONF_ID + "'";
ContentValues cv = new ContentValues();
cv.put("ID", CONF_ID);
cv.put("CONFVAL", c);
try {
db.update(CONFIGURAÇAO_TABLE, cv, where, null);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
db.close();
}
}
/**
* seta a configuraçao do app pela primeira vez
* a diferença desse metodo é que ele n substitui a configuraçao salva,
* ele adiciona uma linha de configuraçao
* <p>
* DEVE SER CHAMADO APENAS QUANDO UMA NOVA CONFIGURAÇAO
* FOR CRIADA, OQUE SÓ DEVE ACONTECER QUANDO O APP FOR ABERTO PELA PRIMEIRA VEZ.
*
* @param c a configuraçao a ser salva
*/
public void setPrimeiraConf(String c) {
System.out.println("Create.setPrimeiraConf");
SQLiteDatabase db = getWritableDatabase();
ContentValues cv = new ContentValues();
cv.put("ID", CONF_ID);
cv.put("CONFVAL", c);
db.insert(CONFIGURAÇAO_TABLE, null, cv);
db.close();
}
public boolean addFolha(folha f) {
SQLiteDatabase db = getWritableDatabase();
try {
ContentValues cv = new ContentValues();
cv.put("NOME_FOLHA", f.getIdentificaçao());
cv.put("MES_FOLHA", f.getMes());
cv.put("RENDA_FOLHA", f.getRenda());
db.insert(FOLHAS_TABLE, null, cv);
db.close();
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* adiciona debitos no banco passado como parametro
*
* @param d
* @param
*/
public void addDebito(debito d) {
SQLiteDatabase db = getWritableDatabase();
ContentValues cv = new ContentValues();
cv.put("ID", d.getIdentificaçao());
cv.put("VALOR", d.getValor());
cv.put("DATA", d.getDataDePagamento());
cv.put("OBSERVACAO", d.getObservaçao());
cv.put("QUITADO", d.isQuitado());
cv.put("FIXO", false);
cv.put("FOLHA", d.getFolha());
cv.put("CATEGORIA", d.getCategoria());
cv.put("N_ID", d.getId());
db.insert(DEBITOS_TABLE, null, cv);
System.out.println("Update.addDebito adiconando debito " + d.getIdentificaçao());
db.close();
return;
}
/**
* adiciona o debitoFixo no banco de debitos fixos
*
* @param d O debito que sera adicionado
* @return TRUE se tudo deu certo, FALSE se houve algum erro.
*/
public boolean addDebitoFixo(debito d) {
SQLiteDatabase db = getWritableDatabase();
ContentValues cv = new ContentValues();
cv.put("ID", d.getIdentificaçao());
cv.put("VALOR", d.getValor());
cv.put("DATA", d.getDataDePagamento());
cv.put("OBSERVACAO", d.getObservaçao());
cv.put("QUITADO", d.isQuitado());
cv.put("FIXO", d.isFixo());
cv.put("FOLHA", d.getFolha());
cv.put("CATEGORIA", d.getCategoria());
cv.put("N_ID", d.getId());
try {
db.insert(DEBITOFIXO_TABLE, null, cv);
System.out.println("Create.addDebitoFixo adicionando debito fixo " + d.getIdentificaçao());
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
db.close();
}
}
/**
* recebe o debito editado a id ( que servira pra saber qual debito no banco de dados sera
* atualizada.
*
* @param DebID A id original do debito
* @param d o novo debito que ira substituir o debito igual a id recebida
*/
public boolean updateDebito(String DebID, debito d) {
SQLiteDatabase db = getWritableDatabase();
String where = "N_ID" + "='" + DebID + "'";
ContentValues cv = new ContentValues();
cv.put("ID", d.getIdentificaçao());
cv.put("VALOR", d.getValor());
cv.put("DATA", d.getDataDePagamento());
cv.put("OBSERVACAO", d.getObservaçao());
cv.put("QUITADO", d.isQuitado());
cv.put("FIXO", d.isFixo());
cv.put("FOLHA", d.getFolha());
cv.put("CATEGORIA", d.getCategoria());
cv.put("N_ID", d.getId());
try {
db.update(DEBITOS_TABLE, cv, where, null);
System.out.println("Create.updateDebito debito atualizado de " + DebID + " para " + d.getIdentificaçao());
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
db.close();
}
}
/**
* quando a folhe é edita esse metodo é chamado para editar a
* propriedade folha de cada debito para que nao se percam
*
* @param oldNomeFolha o nome antigo da folha que sera subistituido
* @param novoNomeFolha o nome da folha que sera usado para atualizar os debitos
*/
public boolean updateDebitoFolha(String oldNomeFolha, String novoNomeFolha) {
SQLiteDatabase db = getWritableDatabase();
String where = "FOLHA" + "='" + oldNomeFolha + "'";
ContentValues cv = new ContentValues();
cv.put("FOLHA", novoNomeFolha);
try {
db.update(DEBITOS_TABLE, cv, where, null);
System.out.println("Update.updateDebitoFolha");
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
db.close();
}
}
/**
* altera o registro da folha no banco de dados
*
* @param f folha que contem os novos registros
* @param oldFolha id da antiga folha
*/
public boolean updateFolha(folha f, String oldFolha) {
SQLiteDatabase db = getWritableDatabase();
String where = "NOME_FOLHA" + "='" + oldFolha + "'";
ContentValues cv = new ContentValues();
cv.put("NOME_FOLHA", f.getIdentificaçao());
cv.put("MES_FOLHA", f.getMes());
cv.put("RENDA_FOLHA", f.getRenda());
try {
db.update(DEBITOS_TABLE, cv, where, null);
System.out.println("Create.updateDebito debito atualizado de " + oldFolha + " para " + f.getIdentificaçao());
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
db.close();
}
}
/**
* recebe o debito editado o a id (nome) que servira pra saber qual debito no banco de dados sera
* atualizado.
*
* @param oldNome o nome original do debito (o nome do debito antes dele ser editado)
* @param d o novo debito que ira substituir o debito igual a id recebida
*/
public boolean editDebitoFixo(String oldNome, debito d) {
SQLiteDatabase db = getWritableDatabase();
String where = "ID" + "='" + oldNome + "'";
ContentValues cv = new ContentValues();
cv.put("ID", d.getIdentificaçao());
cv.put("VALOR", d.getValor());
cv.put("DATA", d.getDataDePagamento());
cv.put("OBSERVACAO", d.getObservaçao());
cv.put("QUITADO", d.isQuitado());
cv.put("FIXO", d.isFixo());
cv.put("FOLHA", d.getFolha());
cv.put("CATEGORIA", d.getCategoria());
cv.put("N_ID", d.getId());
try {
db.update(DEBITOFIXO_TABLE, cv, where, null);
System.out.println("Create.editDebitoFIXO debito fixo atualizado de " + oldNome + " para " + d.getIdentificaçao());
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
db.close();
}
}
}
É isso, preciso saber o porque desse erro e como corrigi-lo, Obg.