A conexão de banco de dados nesta classe é reutilizável?

O problema que você enfrenta é que você se codificou em um canto de "nova conexão por ação". O que você realmente deseja, e é considerado uma prática recomendada, é "nova conexão por lote de ações".

O que eu recomendo neste caso é abrir a conexão quando necessário, e fechar quando descartado. O que faremos é mover os adaptadores odbc para uma variável com escopo maior para que possa ser acessada dentro da classe.

namespace databaseFunctions
{
    public class databaseConnection:IDisposable
    {
        private OdbcConnection con;
        private string connectionString;

        public databaseConnection(string connectionString){
            this.connectionString = connectionString;
        }


        public void OpenConnection(){
            if (con == null || con.IsClosed ){ // we make sure we're only opening connection once.
                con = new OdbcConnection(this.connectionString);
            }
        }
        public void CloseConnection(){
            if (con != null && con.IsOpen){ // I'm making stuff up here
                con.Close();
            }
        }

        public DataTable getFromDatabase(string SQL)
        {
            OpenConnection();

            DataTable rt = new DataTable();
            DataSet ds = new DataSet();
            OdbcCommand cmd = new OdbcCommand(SQL, con);
            da.SelectCommand = cmd;
            da.Fill(ds);
            try
            {
                rt = ds.Tables[0];
            }
            catch
            {   
                rt = null;
            }
            return rt;
        }

        public Boolean insertIntoDatabase(string SQL)
        {
            OpenConnection();

            OdbcCommand cmd = new OdbcCommand(SQL, con);
            con.Open();
            try
            {
                cmd.ExecuteNonQuery();
                return true;
            }
            catch
            {
                return false;
            }

        }


        // Implementing IDisposable method
        public void Dispose(){
            CloseConenction();
        }
    }
}

Agora, da próxima vez que você usar sua classe, faça algo como

using (DatabaseConnection db = new DatabaseConnection()){
    db.InsertIntoDatabase(...);
    db.GetLastInsertID();
    db.GetFromDatabase(...);
}

No final desse bloco de código, por ser IDisposeable, ele fechará essa conexão para você no método de descarte.

Coisas que mudei:

implementado IDisposable interface
alterou os métodos de métodos estáticos para métodos de classe.
adicionados novos métodos para abrir a conexão de fechamento
variável de conexão movida para escopo de nível de classe
adicionou um argumento ao construtor que permite passar uma string de conexão (você deve colocar esta string de conexão em seu Web.Config

Editar% s:

O construtor recebe connectionString por sugestão.