Cursor object not returning data properly.

[Mike Sabo]

I'm sure i'm doing something wrong, and i'm hoping somebody can help me with my problem. I'm trying to run a select query to a database to return a cursor object, then pass that object to another class, or BB screen. From what I can tell, my sql statement isn't returning any data within the object. Here is my code:

MyDatabaseUtils Class

import net.rim.device.api.database.*;
import net.rim.device.api.io.*;
import net.rim.device.api.ui.component.Dialog;

public final class MyDatabaseUtils 
{
    private static Database theDb;
    private static Statement st;
    private static String currentDbName = "none";
    private static Cursor cursor;
    
    // constructor not used
    MyDatabaseUtils() 
    {    
    }
    
    // this method creates the Database and the table
    public static void createDb(String dbName) throws Exception
    { 
        try
        {
            // create db
            URI strURI = URI.create("/SDCard/" + dbName + ".db");
            theDb = DatabaseFactory.create(strURI);
            currentDbName = dbName;
            createTable();
            closeDb();
            
            // write success message
            Dialog.ask(Dialog.D_OK, "Database Created!");
        }
        catch (Exception e)
        {
            Dialog.alert("" +  e.getMessage());
        }
    }
    
    // this method opens an existing database
    public static void openDb(String dbName) throws Exception
    {
       try
        {
            URI strURI = URI.create("/SDCard/" + dbName + ".db");
            theDb = DatabaseFactory.open(strURI);
            currentDbName = dbName;
            
            // write success message
            Dialog.ask(Dialog.D_OK, "Database Opened!");
        }
       catch (Exception e)
        {
           Dialog.alert("" + e.getMessage());
        }
    }
    
    // this method creates the db table
    public static void createTable() throws Exception
    {
        try
        {   
            st = theDb.createStatement("CREATE TABLE 'People'('Name' TEXT, 'Age' INTEGER )");            
            // prepare the statement for execution
            st.prepare();            
            
            // execute the statement
            st.execute();
            
            // close the statement
            st.close();          
        }
        catch (Exception e)
        {
            Dialog.alert("" + e.getMessage());
        }
    }
    
    // this method closes the database
    public static void closeDb() throws Exception
    {
        try
        {
            theDb.close();
        }
        catch (Exception e)
        {
            Dialog.alert(e.getMessage());  
        }
    }
    
    // this method inserts a row into the open database
    public static void insertRow(String aName, int aAge) throws Exception
    {
        try
        {            
            // use the bind method to bind vari(ables to parameters in the statement
            // create a statement with ? place holders for data to be bound
            st = theDb.createStatement("INSERT INTO People(Name,Age) VALUES(?,?)");
            
            // prepare the statement for execution
            st.prepare();
        
            // setup bindings
            st.bind(1, aName);      // bind to the 1st ?
            st.bind(2, aAge);       // bind to the 2nd ?  
            
            // execute and then close the statement
            st.execute();
            st.close();
            // write success message
            Dialog.ask(Dialog.D_OK, "Row Created!");
        }
        catch (Exception e)
        {
            Dialog.alert(e.getMessage());
        }
    }
    
    // this method updates a row in the database
    public static void updateRow(String aName, int aAge) throws Exception
    {
        
    }
    
    public static Cursor GetData() throws Exception
    {

		//routine for getting data from database
		st = theDb.createStatement("SELECT * FROM People ORDER BY Name");
		st.prepare();
		st.execute();
		cursor = st.getCursor();
   		return cursor;
    }
    
    public static void CloseCursor() throws Exception
    {
        cursor.close(); //This method is called to close the database utilities cursor object once the data has been loaded to the screen.
    }
    
    // this method deletes a row in the database
    public static void deleteRow(String aName) throws Exception
    {
        
    }
    
    // returns the current database name
    public static String getCurrentDbName()
    {
        return currentDbName;
    }
}

TableScreen class - this is the screen im trying to display my data on; within a table.

/**
 * File:        TableScreen.java
 * Author:      Mike Sabo
 * Date:        11/9/2011
 * Description: display data from an SQLite database in a table
 *
 */

import net.rim.device.api.database.Cursor;
import net.rim.device.api.database.Row;
import net.rim.device.api.ui.*;
import net.rim.device.api.ui.component.*;
import net.rim.device.api.ui.container.*;
import net.rim.device.api.util.*;
import net.rim.device.api.ui.component.table.*;


public class TableScreen extends MainScreen
{
    // Declare references to table objects.
    private static TableModel tableModel; 
    private TableView tableView;
    private TableController tableController;
    private MyTemplate theTemplate;
    
    // declare labels
    private LabelField screenNameLabel;
    private static LabelField currentDbLabel;
    
    // declare managers
    private HorizontalFieldManager horizontalManager1;
    private HorizontalFieldManager horizontalManager2;
    
    // declare references to the buttons
    private ButtonField updateBtn;
    private ButtonField deleteBtn;
    
    // Menu Items
    private MenuItem menuItemDatabase;
    private MenuItem menuItemInsert;
    
    // DB Objects
    private static Cursor cursor2;
    private static Row row;
    
    // Screen constructor
    public TableScreen()
    {
        super(Manager.NO_VERTICAL_SCROLL);
        //super(); // does not work.
        
        setTitle("Table Screen by Mike Sabo v900");
        
        // Get the font and create the label for the screen
        FontFamily fontFamily[] = FontFamily.getFontFamilies();
        // Returns a font specified by style and size.
        Font font = fontFamily[2].getFont(FontFamily.CBTF_FONT, 28);
        screenNameLabel = new LabelField("List All Rows");
        screenNameLabel.setFont(font);
        // add the label to a horizontal manager
        horizontalManager1 = new HorizontalFieldManager(HorizontalFieldManager.FIELD_HCENTER);
        horizontalManager1.add(screenNameLabel);
        add(horizontalManager1);
        
        // create the label for the current database
        horizontalManager2 = new HorizontalFieldManager(HorizontalFieldManager.FIELD_HCENTER);
        currentDbLabel = new LabelField("Current Database: " + MyDatabaseUtils.getCurrentDbName());
        horizontalManager2.add(currentDbLabel);
        add(horizontalManager2);
        add(new SeparatorField());      // separator
        
        // Implemetation of AbstractTableModel that allows storage of any kind of data and supports all accessor/mutator methods.
        // we will be storing Strings in our table
        tableModel = new TableModel();
        
        // A view interface for TableView as part of a Model-View-Controller paradigm. 
        // Implementations of TableView should handle painting, layout and focus events.
        tableView = new TableView(tableModel);
        
        // A controller class for table components. Implementations of TableController should handle user input and programmatic 
        // requests by notifying the model of possible changes, e.g. updating the contents of a table row. 
        // It may also be necessary for the controller to modify the view directly, e.g. visual state changes such as focus. 
        // Each TableController must provide references to a DataModel and a DataView. 
        tableController = new TableController(tableModel,tableView); //, TableController.FIELD_FOCUS);
        
        // Records a reference to the controller to which the view delegates all input handling events. 
        tableView.setController(tableController);
        
        //Initialize the DataTemplate. DataTemplate is an abstract class
        // template represents repeated data in the table
        // see MyTemplate below
        theTemplate = new MyTemplate(tableView, 1, 2); // DataView, Rows, Columns
        
        // Create a region that can span rows and or columns using the default style.
        // In our case, 1 region for each column
        theTemplate.createRegion(new XYRect(0,0,1,1));
        theTemplate.createRegion(new XYRect(1,0,1,1));
     
        // Set the row properties for the provided row.
        // Creates a row property with the specified height and the TemplateRowProperties.PIXEL_HEIGHT style.
        theTemplate.setRowProperties(0, new TemplateRowProperties(20)); // was 20
        
        // Set the column properties for the provided column.
        // Creates a column property with the specified width and the TemplateColumnProperties.PIXEL_WIDTH style.
        theTemplate.setColumnProperties(0, new TemplateColumnProperties(150));
        theTemplate.setColumnProperties(1, new TemplateColumnProperties(150));
 
        // set fixed height to true
        theTemplate.useFixedHeight(true);
        
        // Sets the assigned DataTemplate for a particular row in the DataModel.
        tableView.setDataTemplate(theTemplate);
        
        // create strings for column headings for the table.
        String[] row = {"Name", "Age"};
        //Add the Strings to the table.
        tableModel.addRow(row); 
        
        // add the table to the screen 
        add(tableView);
        
        // create the update button listener
        FieldChangeListener UpdateListener = new FieldChangeListener()
        {      
            public void fieldChanged(Field field, int context)
            {
                // if user selected any row other than zero
                // push the update screen
                if(tableView.getRowNumberWithFocus() != 0)
                {
                    // get the app object
                    Midterm theApp = (Midterm)UiApplication.getUiApplication();
                    //pop active screen,
                    UiApplication.getUiApplication().popScreen(Ui.getUiEngine().getActiveScreen());
                    // set name and age before pushing screen
                    // get the string data stored in the table model                     
                    Object[] row = (Object[])tableModel.getRow(tableView.getRowNumberWithFocus());
                    theApp.updateScreen.setName((String)row[0]);
                    theApp.updateScreen.setAge((String)row[1]);
                    // use the app object to push the existing Update Screen
                    theApp.pushScreen(theApp.updateScreen);
                }
                tableView.setFocus();
                tableView.setCurrentLocation(0,0);         
            }
        };
        
        // create the delete button listener
        FieldChangeListener DeleteListener = new FieldChangeListener()
        {
            public void fieldChanged(Field field, int context)
            {
                // cast the field to a Button Field.
                ButtonField button = (ButtonField) field;
                button.setDirty(false); 
                
                // only remove if number of rows > 1 since we want to keep the column headings
                if(tableView.getRowNumberWithFocus() != 0)
                {
                    // get the string data stored in the table model                     
                    Object[] row = (Object[])tableModel.getRow(tableView.getRowNumberWithFocus());
                    if(Dialog.ask(Dialog.D_YES_NO, "Delete: " + row[0] + ", " + row[1], Dialog.NO ) == Dialog.YES)
                    {
                        tableModel.removeRowAt(tableView.getRowNumberWithFocus()); 
                        
                        try
                        {
                            MyDatabaseUtils.deleteRow((String)row[0]);
                        }
                        catch(Exception e)
                        {
                            Dialog.alert(e.getMessage());
                        }      
                    }          
                }
                tableView.setFocus();
            }
        };

        
        // create the buttons
        updateBtn = new ButtonField("Update", ButtonField.CONSUME_CLICK);
        deleteBtn = new ButtonField("Delete", ButtonField.CONSUME_CLICK);
        
        // Set the change listeners
        updateBtn.setChangeListener(UpdateListener);
        deleteBtn.setChangeListener(DeleteListener);
        
        // add a horizontal manager and add the buttons to it, then add the manager to the screen
        HorizontalFieldManager hManager = new HorizontalFieldManager(HorizontalFieldManager.FIELD_HCENTER);
        hManager.add(updateBtn);
        hManager.add(deleteBtn);
        add(hManager);
        
        /************************* Menu Items ******************************************/
         
        // this item displays the database screen
        menuItemDatabase = new MenuItem(new StringProvider("Database"), 10, 40)
        {
            //The run command will be called when the user clicks on the MenuItem
            public void run()
            {
                // get the app object
                Midterm theApp = (Midterm)UiApplication.getUiApplication();
                //pop active screen,
                UiApplication.getUiApplication().popScreen(Ui.getUiEngine().getActiveScreen());
                // use the app object to push the existing database Screen
                theApp.pushScreen(theApp.databaseScreen);
            }
        };
        
        // this item displays the insert screen
        menuItemInsert = new MenuItem(new StringProvider("Insert"), 20, 40)
        {
            //The run command will be called when the user clicks on the MenuItem
            public void run()
            {
                // get the app object
                Midterm theApp = (Midterm)UiApplication.getUiApplication();
                //pop active screen,
                UiApplication.getUiApplication().popScreen(Ui.getUiEngine().getActiveScreen());
                // use the app object to push the existing insert Screen
                theApp.pushScreen(theApp.insertScreen);
            }
        };
        
        // add the menu items to the menu 
        addMenuItem(menuItemDatabase); 
        addMenuItem(menuItemInsert);
        addMenuItem(MenuItem.separator(30));    // add a seperator
    }
        
    // This method gets called when the screen is attached or detached from the UI Engine
    // When the screen is attached, update the table
    public static void loadData()
    {
        try
        {
            cursor2 = MyDatabaseUtils.GetData();
            while(cursor2.next()) 
            {
                row = cursor2.getRow();
                tableModel.addRow(new String[]{String.valueOf(row.getInteger(0)),
                                            row.getString(1),
                                                String.valueOf(row.getInteger(2))});
            }
            cursor2.close();
            MyDatabaseUtils.CloseCursor();
        }
        catch (Exception e)
        {
        	Dialog.alert(e.getMessage());
        }    
    }
    
    public static void setDbLabel()
    {
    	currentDbLabel.setText("Current Database: " + MyDatabaseUtils.getCurrentDbName());
    }
    
        
    // called on menu close
    public boolean onClose()
    {
        // ask the user if they are sure
        if(Dialog.ask(Dialog.D_YES_NO, "Are you sure you wish to quit?", Dialog.NO ) == Dialog.YES)
        {
            try
            {
                // close the database
                MyDatabaseUtils.closeDb();
            }
            catch(Exception e)
            {
                Dialog.alert(e.getMessage());
            }
            
            System.exit(0);
            return true;
        }
        return false;
    }
    
    // Define a repeating layout of fields from data obtained from the model associated with the DataTemplate's view. 
    static public class MyTemplate extends DataTemplate
    {
        // constructor calls super.
        public MyTemplate(DataView dataView, int rows, int columns)
        {
            super(dataView, rows, columns);
        }
        
        // return the row as an array of Fields
        public Field[] getDataFields(int modelRowIndex) 
        {
            TableModel theModel = (TableModel) getView().getModel();
            
            //Get the data for the row.
            Object[] data = (Object[]) theModel.getRow(modelRowIndex);
            
            //Create a array to hold all fields.
            Field[] theDataFields = new Field[data.length];
            
            //Create a LabelField with each String in the model.
            for(int i=0; i < data.length; i++) 
            {
                LabelField field = new LabelField("",LabelField.FIELD_HCENTER);
                field.setText((String) data[i]);
                theDataFields[i] = field;
            }
            return theDataFields;
        }   
    }
}