dojox/storage/AirDBStorageProvider.js

  • Provides:

    • dojox.storage.AirDBStorageProvider

  • Requires:

    • dojox.storage.manager in common
    • dojox.storage.Provider in common

  • dojox.storage.AirDBStorageProvider

    • type
      Function
    • chains:
      • dojox.storage.Provider: (prototype)
      • dojox.storage.Provider: (call)
    • summary
  • dojox.storage.AirDBStorageProvider.DATABASE_FILE
       
    • summary
  • dojox.storage.AirDBStorageProvider.TABLE_NAME
       
    • summary
  • dojox.storage.AirDBStorageProvider.initialized
       
    • summary
  • dojox.storage.AirDBStorageProvider._db
       
    • summary
  • dojox.storage.AirDBStorageProvider.initialize
       
    • type
      Function
    • source: [view] 
                    
      

                        this.initialized = false;


          // need to initialize our storage database
          try{
           this._db = new air.SQLConnection();
           this._db.open(air.File.applicationStorageDirectory.resolvePath(this.DATABASE_FILE));

           
           this._sql("CREATE TABLE IF NOT EXISTS " + this.TABLE_NAME + "(namespace TEXT, key TEXT, value TEXT)");
           this._sql("CREATE UNIQUE INDEX IF NOT EXISTS namespace_key_index ON " + this.TABLE_NAME + " (namespace, key)");

           
           this.initialized = true;
          }catch(e){
           console.debug("dojox.storage.AirDBStorageProvider.initialize:", e);
          }

          
          // indicate that this storage provider is now loaded
          dojox.storage.manager.loaded();
                    
      
                    
    • summary
  • dojox.storage.AirDBStorageProvider._sql
       
    • type
      Function
    • parameters: 
      • query: (typeof )
      • params: (typeof )
    • source: [view] 
                    
      

                        var stmt = new air.SQLStatement();
          stmt.sqlConnection = this._db;
          stmt.text = query;
          if (params){
           for (var param in params){
            stmt.parameters[param] = params[param];
           }
          }
          stmt.execute();
          return stmt.getResult();
                    
      
                    
    • summary
  • dojox.storage.AirDBStorageProvider._beginTransaction
       
    • type
      Function
    • source: [view] 
                    
      

                        this._db.begin();
                    
      
                    
    • summary
  • dojox.storage.AirDBStorageProvider._commitTransaction
       
    • type
      Function
    • source: [view] 
                    
      

                        this._db.commit();
                    
      
                    
    • summary
  • dojox.storage.AirDBStorageProvider.isAvailable
       
    • type
      Function
    • source: [view] 
                    
      

                        return true;
                    
      
                    
    • summary
  • dojox.storage.AirDBStorageProvider.put
       
    • type
      Function
    • parameters: 
      • key: (typeof )
      • value: (typeof )
      • resultsHandler: (typeof )
      • namespace: (typeof )
    • source: [view] 
                    
      

                        if(this.isValidKey(key) == false){
           throw new Error("Invalid key given: " + key);
          }
          namespace = namespace||this.DEFAULT_NAMESPACE;
          if(this.isValidKey(namespace) == false){
           throw new Error("Invalid namespace given: " + namespace);
          }

          
          // try to store the value
          try{
           this._sql("DELETE FROM " + this.TABLE_NAME + " WHERE namespace = :namespace AND key = :key",
            { ":namespace":namespace, ":key":key });
           this._sql("INSERT INTO " + this.TABLE_NAME + " VALUES (:namespace, :key, :value)",
            { ":namespace":namespace, ":key":key, ":value":value });
          }catch(e){
           // indicate we failed
           console.debug("dojox.storage.AirDBStorageProvider.put:", e);
           resultsHandler(this.FAILED, key, e.toString());
           return;
          }

          
          if(resultsHandler){
           resultsHandler(this.SUCCESS, key, null, namespace);
          }
                    
      
                    
    • summary
  • dojox.storage.AirDBStorageProvider.get
       
    • type
      Function
    • parameters: 
      • key: (typeof )
      • namespace: (typeof )
    • source: [view] 
                    
      

                        if(this.isValidKey(key) == false){
           throw new Error("Invalid key given: " + key);
          }
          namespace = namespace||this.DEFAULT_NAMESPACE;

          
          var results = this._sql("SELECT * FROM " + this.TABLE_NAME + " WHERE namespace = :namespace AND key = :key",
           { ":namespace":namespace, ":key":key });

          
          if(results.data && results.data.length){
           return results.data[0].value;
          }

          
          return null;
                    
      
                    
    • summary
  • dojox.storage.AirDBStorageProvider.getNamespaces
       
    • type
      Function
    • source: [view] 
                    
      

                        var results = [ this.DEFAULT_NAMESPACE ];
          var rs = this._sql("SELECT namespace FROM " + this.TABLE_NAME + " DESC GROUP BY namespace");
          if (rs.data){
           for(var i = 0; i < rs.data.length; i++){
            if(rs.data[i].namespace != this.DEFAULT_NAMESPACE){
             results.push(rs.data[i].namespace);
            }
           }
          }
          return results;
                    
      
                    
    • summary
  • dojox.storage.AirDBStorageProvider.getKeys
       
    • type
      Function
    • parameters: 
      • namespace: (typeof )
    • source: [view] 
                    
      

                        namespace = namespace||this.DEFAULT_NAMESPACE;
          if(this.isValidKey(namespace) == false){
           throw new Error("Invalid namespace given: " + namespace);
          }

          
          var results = [];
          var rs = this._sql("SELECT key FROM " + this.TABLE_NAME + " WHERE namespace = :namespace", { ":namespace":namespace });
          if (rs.data){
           for(var i = 0; i < rs.data.length; i++){
            results.push(rs.data[i].key);
           }
          }
          return results;
                    
      
                    
    • summary
  • dojox.storage.AirDBStorageProvider.clear
       
    • type
      Function
    • parameters: 
      • namespace: (typeof )
    • source: [view] 
                    
      

                        if(this.isValidKey(namespace) == false){
           throw new Error("Invalid namespace given: " + namespace);
          }
          this._sql("DELETE FROM " + this.TABLE_NAME + " WHERE namespace = :namespace", { ":namespace":namespace });
                    
      
                    
    • summary
  • dojox.storage.AirDBStorageProvider.remove
       
    • type
      Function
    • parameters: 
      • key: (typeof )
      • namespace: (typeof )
    • source: [view] 
                    
      

                        namespace = namespace||this.DEFAULT_NAMESPACE;
          this._sql("DELETE FROM " + this.TABLE_NAME + " WHERE namespace = :namespace AND key = :key",
           { ":namespace":namespace, ":key":key });
                    
      
                    
    • summary
  • dojox.storage.AirDBStorageProvider.putMultiple
       
    • type
      Function
    • parameters: 
      • keys: (typeof )
      • values: (typeof )
      • resultsHandler: (typeof )
      • namespace: (typeof )
    • source: [view] 
                    
      

                        if(this.isValidKeyArray(keys) === false
            || ! values instanceof Array
            || keys.length != values.length){
           throw new Error("Invalid arguments: keys = [" + keys + "], values = [" + values + "]");
          }

          
          if(namespace == null || typeof namespace == "undefined"){
           namespace = this.DEFAULT_NAMESPACE;
          }

       
          if(this.isValidKey(namespace) == false){
           throw new Error("Invalid namespace given: " + namespace);
          }

       
          this._statusHandler = resultsHandler;


          // try to store the value
          try{
           this._beginTransaction();
           for(var i=0;i      this._sql("DELETE FROM " + this.TABLE_NAME + " WHERE namespace = :namespace AND key = :key",
             { ":namespace":namespace, ":key":keys[i] });
            this._sql("INSERT INTO " + this.TABLE_NAME + " VALUES (:namespace, :key, :value)",
              { ":namespace":namespace, ":key":keys[i], ":value":values[i] });
           }
           this._commitTransaction();
          }catch(e){
           // indicate we failed
           console.debug("dojox.storage.AirDBStorageProvider.putMultiple:", e);
           if(resultsHandler){
            resultsHandler(this.FAILED, keys, e.toString(), namespace);
           }
           return;
          }

          
          if(resultsHandler){
           resultsHandler(this.SUCCESS, keys, null);
          }
                    
      
                    
    • summary
  • dojox.storage.AirDBStorageProvider.getMultiple
       
    • type
      Function
    • parameters: 
      • keys: (typeof )
      • namespace: (typeof )
    • source: [view] 
                    
      

                        if(this.isValidKeyArray(keys) === false){
           throw new Error("Invalid key array given: " + keys);
          }

          
          if(namespace == null || typeof namespace == "undefined"){
           namespace = this.DEFAULT_NAMESPACE;
          }

          
          if(this.isValidKey(namespace) == false){
           throw new Error("Invalid namespace given: " + namespace);
          }

        
          var results = [];
          for(var i=0;i     var result = this._sql("SELECT * FROM " + this.TABLE_NAME + " WHERE namespace = :namespace AND key = :key",
            { ":namespace":namespace, ":key":keys[i] });
           results[i] = result.data && result.data.length ? result.data[0].value : null;
          }

          
          return results;
                    
      
                    
    • summary
  • dojox.storage.AirDBStorageProvider.removeMultiple
       
    • type
      Function
    • parameters: 
      • keys: (typeof )
      • namespace: (typeof )
    • source: [view] 
                    
      

                        namespace = namespace||this.DEFAULT_NAMESPACE;

          
          this._beginTransaction();
          for(var i=0;i     this._sql("DELETE FROM " + this.TABLE_NAME + " WHERE namespace = namespace = :namespace AND key = :key",
            { ":namespace":namespace, ":key":keys[i] });
          }
          this._commitTransaction();
                    
      
                    
    • summary
  • dojox.storage.AirDBStorageProvider.isPermanent
       
    • type
      Function
    • source: [view] 
                    
      

                       isPermanent: function(){ return true; 
                    
      
                    
    • summary
  • dojox.storage.AirDBStorageProvider.getMaximumSize
       
    • type
      Function
    • source: [view] 
                    
      

                       getMaximumSize: function(){ return this.SIZE_NO_LIMIT; 
                    
      
                    
    • summary
  • dojox.storage.AirDBStorageProvider.hasSettingsUI
       
    • type
      Function
    • source: [view] 
                    
      

                       hasSettingsUI: function(){ return false; 
                    
      
                    
    • summary
  • dojox.storage.AirDBStorageProvider.showSettingsUI
       
    • type
      Function
    • source: [view] 
                    
      

                        throw new Error(this.declaredClass + " does not support a storage settings user-interface");
                    
      
                    
    • summary
  • dojox.storage.AirDBStorageProvider.hideSettingsUI
       
    • type
      Function
    • source: [view] 
                    
      

                        throw new Error(this.declaredClass + " does not support a storage settings user-interface");
                    
      
                    
    • summary
  • dojox.storage.AirDBStorageProvider._statusHandler
       
    • summary
  • air.File
       
    • summary
  • air.SQLConnection
       
    • summary
  • air.SQLStatement
       
    • summary
  • dojox.storage
       
    • type
      Object
    • summary
  • dojox
       
    • type
      Object
    • summary