Changeset 3636:edc4121df2a0 in orange


Ignore:
Timestamp:
05/09/07 10:31:27 (7 years ago)
Author:
polz <polz@…>
Branch:
default
Convert:
72c7da00cab67e7cf71a349adf1f83d4aadcdaac
Message:

Removed shebang (#!) from orngSQL.py

File:
1 edited

Legend:

Unmodified
Added
Removed
  • orange/orngSQL.py

    r3588 r3636  
    1 #!/usr/bin/python 
    21# A module to read data from an SQL database into an Orange ExampleTable. 
    32# The goal is to keep it compatible with PEP 249. 
     
    1514        self.domain = None 
    1615        self.exampleTable = None 
     16        self.metaNames = None 
     17        self.discreteNames = None 
     18        self.classVarName = None 
     19        self._dirty = False 
    1720         
    1821    def _parseURI(self, uri): 
     
    9598        if path: 
    9699            dbArgDict['database'] = path[1:] 
     100        self._dirty = True 
    97101        self.conn = self.dbmod.connect(**dbArgDict) 
    98          
    99     def query(self, s, discreteAttrs = None, classAttr = None, metaAttrs = None): 
    100         """executes a read query and constructs the orange.Domain. 
    101         If the name of the class attribute is not supplied, the first column is used as the class attribute. 
    102         If any of the attributes are considered to be discrete, they should be specified. 
    103         """ 
     102 
     103    def classVar(self, classVarName = None): 
     104        """if classVarName is set, the class variable is set to that value.""" 
     105        if classVarName is not None: 
     106            self.classVarName = classVarName 
     107            self._dirty = True 
     108        self.update() 
     109        return self.domain.classVar 
     110    def setMetaNames(self, metaNames): 
     111        self.metaNames = metaNames 
     112        self._dirty = True 
     113    def getmetas(self, metaAttrNames = None): 
     114        self.update() 
     115        return self.domain.getmetas() 
     116    def setDiscreteNames(self, discreteNames): 
     117        self.discreteNames = discreteNames 
     118        self._dirty = True 
     119         
     120    def setQuery(self, s): 
     121        """sets the query, resets the internal variables, without executing the query""" 
     122        self.query = s 
     123        self.classAttrName = None 
     124        self.metaAttrNames = None 
     125        self._dirty = True 
     126         
     127    def execute(self, s): 
     128        """executes an sql query""" 
     129        self.setQuery(s) 
     130        self.update() 
     131         
     132    def update(self): 
     133        if not self._dirty: 
     134            return self.exampleTable 
    104135        self.exampleTable = None 
    105136        try: 
    106137            curs = self.conn.cursor() 
    107             curs.execute(s) 
     138            curs.execute(self.query) 
    108139            desc = curs.description 
    109             if not classAttr: 
    110                 classAttr = desc[0][0] 
     140            if not self.classVarName: 
     141                classVarName = desc[0][0] 
     142            else: 
     143                classVarName = self.classVarName 
    111144            attrNames = [] 
    112             if not discreteAttrs: 
    113                 discreteAttrs = [] 
    114             if not metaAttrs: 
    115                 metaAttrs = [] 
     145            if not self.discreteNames: 
     146                discreteNames = [] 
     147            else: 
     148                discreteNames = self.discreteNames 
     149            if not self.metaNames: 
     150                metaNames = [] 
     151            else: 
     152                metaNames = self.metaNames 
    116153            for i in desc: 
    117154                name = i[0] 
    118155                typ = i[1] 
    119                 if typ in [self.dbmod.STRING, self.dbmod.DATETIME]: 
     156                if name in discreteNames: 
     157                    attrName = 'D#' + name 
     158                elif typ == self.dbmod.STRING: 
    120159                    attrName = 'S#' + name 
    121                 elif name in discreteAttrs: 
    122                     attrName = 'D#' + name 
     160                elif typ == self.dbmod.DATETIME: 
     161                    attrName = 'S#' + name 
    123162                else: 
    124163                    attrName = 'C#' + name 
    125                 if name == classAttr: 
     164                if name == classVarName: 
    126165                    attrName = "c" + attrName 
    127                 elif name in metaAttrs: 
     166                elif name in metaNames: 
    128167                    attrName = "m" + attrName 
    129168                attrNames.append(attrName) 
     
    142181                self.exampleTable.append(example) 
    143182                r = curs.fetchone() 
     183            self._dirty = False 
    144184        except Exception, e: 
    145185            raise e 
    146186            self.domain = None 
    147187 
     188    def query(self, s, discreteAttrs = None, classVarName = None, metaNames = None): 
     189        """executes a read query and constructs the orange.Domain. 
     190        If the name of the class attribute is not supplied, the first column is used as the class attribute. 
     191        If any of the attributes are considered to be discrete, they should be specified. 
     192        """ 
     193        self.setQuery(s) 
     194        self.setDiscrete(discreteAttrs) 
     195        self.classVar(classVarName) 
     196        self.setMetaNames(metaNames) 
     197        self.update() 
     198 
    148199    def data(self): 
    149         data = None 
     200        self.update() 
    150201        if self.exampleTable: 
    151202            return self.exampleTable 
Note: See TracChangeset for help on using the changeset viewer.