dc_db.DBDataTask.DBDataTask Class Reference

Inheritance diagram for dc_db.DBDataTask.DBDataTask:

Collaboration diagram for dc_db.DBDataTask.DBDataTask:

Public Member Functions
def	__init__ (self, dbDataType=Constants.DB_DATA_KVDB, keyValueDefaultFile=None, dcContentTemplate=None, keyValueStorageDir=None, rawDataDir=None)
def	process (self, dbDataRequest, queryCallback)
def	fetchKVDBSpecificFunct (self, dbConnect, query, response)
def	insertKVDBSpecificFunct (self, dbConnect, query, response)
def	KVDBCommonExecute (self, request, response, specificFunc, query)
def	KVDBFetch (self, request)
def	MySQLFetch (self, request)
def	createInsertQueryKVDB (self, insertDict, supportFields, tableName)
def	createInsertQueryMySQL (self, insertDict, supportFields, tableName)
def	KVDBInsert (self, request)
def	MySQLInsert (self, request)
def	deleteSurroundStorageFiles (self, rawStoragePath, urlMd5)
def	insertFSFunc (self, dbDataRequest)
def	KVDBDelRecord (self, request)
def	KVDBDelTable (self, request)
def	MySQLDelRecord (self, request)
def	MySQLDelTable (self, request)
def	KVDBCreateTable (self, request)
def	MySQLCreateTable (self, request)
def	resolveFileSuffix (self, contentType)
Public Member Functions inherited from dc_db.BaseTask.BaseTask
def	isSiteExist (self, siteId, queryCallback, userId=None)
def	generateCriterionSQL (self, criterions, additionWhere=None, siteId=None)
def	fetchByCriterions (self, criterions, queryCallback)
def	dbLock (self, mutexName, queryCallback, sleepTime=1, mutexLockTTL=Constants.DEFAULT_LOCK_TTL)
def	dbUnlock (self, mutexName, queryCallback)
def	createUrlsInsertQuery (self, siteId, localKeys, localValues)
def	copyUrlsToDcUrls (self, siteId, queryCallback)
def	statisticLogUpdate (self, localObj, urlMd5, siteId, status, queryCallback, isInsert=False)
def	calculateMd5FormUrl (self, url, urlType, useNormilize=False)

Public Attributes
	rawDataDir
	keyValueStorageDir
	dbDataType
	queryCallback
	fetchFunc
	insertFunc
	createTableFunc
	delRecordFunc
	delTableFunc
	keyValueDefaultFile
	dcContentTemplate

Static Public Attributes
string	NO_DIR_STR = "No such file or directory:"

Additional Inherited Members
Static Public Member Functions inherited from dc_db.BaseTask.BaseTask
def	readValueFromSiteProp (siteId, propName, queryCallback, urlMd5=None)

Detailed Description

Definition at line 32 of file DBDataTask.py.

Constructor & Destructor Documentation

__init__()

def dc_db.DBDataTask.DBDataTask.__init__	(		self,
			dbDataType = Constants.DB_DATA_KVDB,
			keyValueDefaultFile = None,
			dcContentTemplate = None,
			keyValueStorageDir = None,
			rawDataDir = None
	)

Definition at line 41 of file DBDataTask.py.

               keyValueStorageDir=None, rawDataDir=None):
    super(DBDataTask, self).__init__()
    self.rawDataDir = rawDataDir
    self.keyValueStorageDir = ""
    self.dbDataType = dbDataType
    self.queryCallback = None
    self.fetchFunc = None
    self.insertFunc = None
    self.createTableFunc = None
    if self.dbDataType == Constants.DB_DATA_KVDB:
      logger.debug(">>> set KVDB")
      self.fetchFunc = self.KVDBFetch
      self.insertFunc = self.KVDBInsert
      self.delRecordFunc = self.KVDBDelRecord
      self.delTableFunc = self.KVDBDelTable
      self.createTableFunc = self.KVDBCreateTable
    elif self.dbDataType == Constants.DB_DATA_MYSQL:
      logger.debug(">>> set MySQL")
      self.fetchFunc = self.MySQLFetch
      self.insertFunc = self.MySQLInsert
      self.delRecordFunc = self.MySQLDelRecord
      self.delTableFunc = self.MySQLDelTable
      self.createTableFunc = self.MySQLCreateTable
    self.keyValueDefaultFile = keyValueDefaultFile
    self.dcContentTemplate = dcContentTemplate
    self.keyValueStorageDir = keyValueStorageDir

Member Function Documentation

createInsertQueryKVDB()

def dc_db.DBDataTask.DBDataTask.createInsertQueryKVDB	(		self,
			insertDict,
			supportFields,
			tableName
	)

Definition at line 172 of file DBDataTask.py.

  def createInsertQueryKVDB(self, insertDict, supportFields, tableName):
    mainSQL = "REPLACE INTO `%s`"
    valusesStr = "VALUES("
    fieldsStr = "("
    for key in insertDict:
      if key in supportFields and insertDict[key] is not None:
        fieldsStr += "`"
        fieldsStr += key
        fieldsStr += "`,"

        if type(insertDict[key]) in types.StringTypes or type(insertDict[key]) == datetime.datetime:
          valusesStr += "'"
        valusesStr += str(insertDict[key])
        if type(insertDict[key]) in types.StringTypes or type(insertDict[key]) == datetime.datetime:
          valusesStr += "'"
        valusesStr += ","
      else:
        logger.debug(">>> field not in Constants fields list field or None value = " + key)
    if valusesStr[-1] == ",":
      valusesStr = valusesStr[0:-1]
    if fieldsStr[-1] == ",":
      fieldsStr = fieldsStr[0:-1]
    valusesStr += ")"
    fieldsStr += ")"

    query = mainSQL % tableName
    query += " "
    query += fieldsStr
    query += " "
    query += valusesStr
    return query

Here is the caller graph for this function:

createInsertQueryMySQL()

def dc_db.DBDataTask.DBDataTask.createInsertQueryMySQL	(		self,
			insertDict,
			supportFields,
			tableName
	)

Definition at line 205 of file DBDataTask.py.

  def createInsertQueryMySQL(self, insertDict, supportFields, tableName):
    keyList = []
    valueList = []
    SQL_INSERT_TEMPLATE = "INSERT INTO %s SET %s ON DUPLICATE KEY UPDATE %s"
    for key in insertDict:
      if key in supportFields and insertDict[key] is not None:
        keyList.append(key)
        if type(insertDict[key]) in types.StringTypes:
          escapingStr = MySQLdb.escape_string(str(insertDict[key]))
          valueList.append(("'" + escapingStr + "'"))
        else:
          valueList.append(str(insertDict[key]))
    setString = Constants.createFieldsValuesString(keyList, valueList)
    query = ""
    if len(setString) > 0:
      query = SQL_INSERT_TEMPLATE % (tableName, setString, setString)
    else:
      logger.debug(">>> createInsertQueryMySQL empty SET list")
    return query

Here is the caller graph for this function:

deleteSurroundStorageFiles()

def dc_db.DBDataTask.DBDataTask.deleteSurroundStorageFiles	(		self,
			rawStoragePath,
			urlMd5
	)

Definition at line 252 of file DBDataTask.py.

  def deleteSurroundStorageFiles(self, rawStoragePath, urlMd5):
    delContentTypes = [dc.EventObjects.Content.CONTENT_TIDY_CONTENT, dc.EventObjects.Content.CONTENT_HEADERS_CONTENT,
                       dc.EventObjects.Content.CONTENT_REQUESTS_CONTENT, dc.EventObjects.Content.CONTENT_META_CONTENT,
                       dc.EventObjects.Content.CONTENT_COOKIES_CONTENT, dc.EventObjects.Content.CONTENT_DYNAMIC_CONTENT]

    for cType in delContentTypes:
      localFileSuffix = self.resolveFileSuffix(cType)
      rawStorageFileName = Utils.accumulateSubstrings([urlMd5, None, localFileSuffix], ["", "_", ""])
      localPath = rawStoragePath + rawStorageFileName
      try:
        os.remove(localPath)
      except OSError:
        pass

Here is the call graph for this function:

Here is the caller graph for this function:

fetchKVDBSpecificFunct()

def dc_db.DBDataTask.DBDataTask.fetchKVDBSpecificFunct	(		self,
			dbConnect,
			query,
			response
	)

Definition at line 112 of file DBDataTask.py.

  def fetchKVDBSpecificFunct(self, dbConnect, query, response):
    dbConnect.row_factory = sqlite3.Row
    cursor = dbConnect.cursor()
    for row in cursor.execute(query):
      response.resultDict = dict(itertools.izip(row.keys(), row))

Here is the caller graph for this function:

insertFSFunc()

def dc_db.DBDataTask.DBDataTask.insertFSFunc	(		self,
			dbDataRequest
	)

Definition at line 267 of file DBDataTask.py.

  def insertFSFunc(self, dbDataRequest):
    logger.debug(">>> insertFSFunc start")
    ret = dc.EventObjects.URLPutResponse(dbDataRequest.contentType)
    if "data" in dbDataRequest.putDict and dbDataRequest.putDict["data"] is not None:
      if self.rawDataDir is not None:
        localFileSuffix = self.resolveFileSuffix(dbDataRequest.contentType)
        rawStoragePath = self.rawDataDir
        if rawStoragePath[-1] != '/':
          rawStoragePath += '/'
        rawStoragePath += str(dbDataRequest.siteId)
        rawStoragePath += '/'
        pathMaker = PathMaker(dbDataRequest.urlMd5)
        rawStoragePath += pathMaker.getDir()
        rawStoragePath += '/'
        rawStorageFileName = Utils.accumulateSubstrings(
                            [dbDataRequest.urlMd5, dbDataRequest.fileStorageSuffix, localFileSuffix], ["", "_", ""])
        localPath = rawStoragePath + rawStorageFileName
        if not os.path.exists(rawStoragePath):
          os.makedirs(rawStoragePath)
          logger.debug(">>> MAKE PATH - " + rawStoragePath)
        if os.path.exists(localPath):
          logger.debug(">>> file is exists - " + localPath)
        if dbDataRequest.contentType == dc.EventObjects.Content.CONTENT_RAW_CONTENT:
          self.deleteSurroundStorageFiles(rawStoragePath, dbDataRequest.urlMd5)
        fd = None
        try:
          fd = open(localPath, "w")
        except IOError as ex:
          if self.NO_DIR_STR in str(ex):
            logger.error(">>> Wrong path, file - " + str(localPath))
          else:
            logger.error(">>> Some file open error, file - " + localPath)
        if fd is not None:
          fd.write(dbDataRequest.putDict["data"])
          fd.flush()
          fd.close()
      else:
        logger.error(">>> rawDataDir is None")
        ret.errCode = 1
        ret.errMessage = ">>> rawDataDir is None"
    else:
      logger.error(">>> 'data' not in dbDataRequest.putDict or dbDataRequest.putDict['data'] is None")
      ret.errCode = 1
      ret.errMessage = ">>> 'data' not in dbDataRequest.putDict or dbDataRequest.putDict['data'] is None"
    return ret

Here is the call graph for this function:

Here is the caller graph for this function:

insertKVDBSpecificFunct()

def dc_db.DBDataTask.DBDataTask.insertKVDBSpecificFunct	(		self,
			dbConnect,
			query,
			response
	)

Definition at line 119 of file DBDataTask.py.

  def insertKVDBSpecificFunct(self, dbConnect, query, response):
    cursor = dbConnect.cursor()
    cursor.execute(query)

Here is the caller graph for this function:

KVDBCommonExecute()

def dc_db.DBDataTask.DBDataTask.KVDBCommonExecute	(		self,
			request,
			response,
			specificFunc,
			query
	)

Definition at line 124 of file DBDataTask.py.

  def KVDBCommonExecute(self, request, response, specificFunc, query):
    dbName = Constants.KEY_VALUE_FILE_NAME_TEMPLATE % request.siteId
    dbFileName = self.keyValueStorageDir + "/" + dbName
    logger.debug(">>> KVDB SQL = " + query)
    logger.debug(">>> KVDB Path = " + str(dbFileName))
    try:
      if os.path.exists(dbFileName):
        dbConnect = sqlite3.connect(dbFileName)  # pylint: disable-all
        dbConnect.text_factory = str
        specificFunc(dbConnect, query, response)
        dbConnect.commit()
      else:
        logger.error(">>> path not exist")
        response.errCode = 1
        response.errMessage = ">>> path not exist"
    except:
      logger.error(">>> some kvdb exception")
      response.errCode = 1
      response.errMessage = ">>> some kvdb exception"

Here is the caller graph for this function:

KVDBCreateTable()

def dc_db.DBDataTask.DBDataTask.KVDBCreateTable	(		self,
			request
	)

Definition at line 379 of file DBDataTask.py.

  def KVDBCreateTable(self, request):
    logger.debug(">>> KVDBCreateTable start")
    ret = dc.EventObjects.DataCreateResponse()
    if self.keyValueDefaultFile is not None:
      keyValueFileName = self.keyValueStorageDir
      if keyValueFileName[-1] != '/':
        keyValueFileName += '/'
      keyValueFileName += (Constants.KEY_VALUE_FILE_NAME_TEMPLATE % request.siteId)
      shutil.copy(self.keyValueDefaultFile, keyValueFileName)
    else:
      logger.error(">>> keyValueDefaultFile is None")
      ret.errCode = 1
      ret.errMessage = ">>> keyValueDefaultFile is None"
    return ret

KVDBDelRecord()

def dc_db.DBDataTask.DBDataTask.KVDBDelRecord	(		self,
			request
	)

Definition at line 314 of file DBDataTask.py.

  def KVDBDelRecord(self, request):
    logger.debug(">>> KVDBDelRecord start")
    ret = dc.EventObjects.DataDeleteResponse()
    dbName = Constants.KEY_VALUE_FILE_NAME_TEMPLATE % request.siteId
    dbFileName = self.keyValueStorageDir + "/" + dbName
    try:
      if os.path.exists(dbFileName):
        dbConnect = sqlite3.connect(dbFileName)  # pylint: disable-all
        dbConnect.text_factory = str
        cursor = dbConnect.cursor()
        cursor.execute("DELETE from `articles` where `id` = '%s'" % request.urlMd5)
        dbConnect.commit()
      else:
        logger.error(">>> path not exist")
        ret.errCode = 1
        ret.errMessage = ">>> path not exist"
    except:
      logger.error(">>> some kvdb exception")
      ret.errCode = 1
      ret.errMessage = ">>> some kvdb exception"
    return ret

KVDBDelTable()

def dc_db.DBDataTask.DBDataTask.KVDBDelTable	(		self,
			request
	)

Definition at line 337 of file DBDataTask.py.

  def KVDBDelTable(self, request):
    logger.debug(">>> KVDBDelTable start")
    ret = dc.EventObjects.DataDeleteResponse()
    try:
      if request.filesSuffix is not None:
        delFile = self.keyValueStorageDir + "/" + (request.filesSuffix % request.siteId)
        logger.debug(">>> Del file = %s", str(delFile))
        os.remove(delFile)
      else:
        logger.error(">>> request.filesSuffix is None")
        ret.errCode = 1
        ret.errMessage = (">>> request.filesSuffix is None")
    except OSError as err:
      logger.error((str(err.filename) + " " + str(err.strerror)))
      ret.errCode = 1
      ret.errMessage = (str(err.filename) + " " + str(err.strerror))
      logger.debug(">>> [KVDBDelTable] CURRENT DIR " + str(os.getcwd()))
    return ret

KVDBFetch()

def dc_db.DBDataTask.DBDataTask.KVDBFetch	(		self,
			request
	)

Definition at line 145 of file DBDataTask.py.

  def KVDBFetch(self, request):
    logger.debug(">>> KVDBFetch start")
    ret = dc.EventObjects.DataFetchResponse({})
    self.KVDBCommonExecute(request, ret, self.fetchKVDBSpecificFunct,
                           (Constants.SELECT_DB_STORAGE % ("articles", request.urlMd5)))
    return ret

Here is the call graph for this function:

KVDBInsert()

def dc_db.DBDataTask.DBDataTask.KVDBInsert	(		self,
			request
	)

Definition at line 226 of file DBDataTask.py.

  def KVDBInsert(self, request):
    logger.debug(">>> KVDBInsert start")
    ret = dc.EventObjects.URLPutResponse(dc.EventObjects.Content.CONTENT_PROCESSOR_CONTENT)
    query = self.createInsertQueryKVDB(request.putDict, Constants.DbContentFields["KVDB"],
                                       Constants.DB_STORAGE_TABLE_NAME)
    self.KVDBCommonExecute(request, ret, self.insertKVDBSpecificFunct, query)
    return ret

Here is the call graph for this function:

MySQLCreateTable()

def dc_db.DBDataTask.DBDataTask.MySQLCreateTable	(		self,
			request
	)

Definition at line 395 of file DBDataTask.py.

  def MySQLCreateTable(self, request):
    logger.debug(">>> MySQLCreateTable start")
    ret = dc.EventObjects.DataCreateResponse()
    if self.dcContentTemplate is not None:
      if self.queryCallback is not None:
        template = open(self.dcContentTemplate).read()
        query = template.replace("%SITE_ID%", str(request.siteId))
        logger.debug(">>> create content_tables id = " + str(request.siteId))
        self.queryCallback(query, Constants.FIFTH_DB_ID)
      else:
        logger.error(">>> queryCallback is None")
        ret.errCode = 1
        ret.errMessage = ">>> queryCallback is None"
    else:
      logger.error(">>> keyValueDefaultFile is None")
      ret.errCode = 1
      ret.errMessage = ">>> keyValueDefaultFile is None"
    return ret

Here is the caller graph for this function:

MySQLDelRecord()

def dc_db.DBDataTask.DBDataTask.MySQLDelRecord	(		self,
			request
	)

Definition at line 357 of file DBDataTask.py.

  def MySQLDelRecord(self, request):
    logger.debug(">>> MySQLDelRecord start")
    ret = dc.EventObjects.DataDeleteResponse()
    if self.queryCallback is not None:
      DELETE_SQL_REQUEST = "DELETE FROM `%s` WHERE `id`='%s'"
      tableName = Constants.DC_CONTENTS_TABLE_NAME_TEMPLATE % request.siteId
      query = DELETE_SQL_REQUEST % (tableName, request.urlMd5)
      self.queryCallback(query, Constants.FIFTH_DB_ID)
    return ret

MySQLDelTable()

def dc_db.DBDataTask.DBDataTask.MySQLDelTable	(		self,
			request
	)

Definition at line 368 of file DBDataTask.py.

  def MySQLDelTable(self, request):
    logger.debug(">>> MySQLDelTable start")
    ret = dc.EventObjects.DataDeleteResponse()
    if self.queryCallback is not None:
      DROP_SQL_REQUEST = "DROP TABLE IF EXISTS `%s`"
      tableName = Constants.DC_CONTENTS_TABLE_NAME_TEMPLATE % request.siteId
      query = DROP_SQL_REQUEST % tableName
      self.queryCallback(query, Constants.FIFTH_DB_ID)
    return ret

MySQLFetch()

def dc_db.DBDataTask.DBDataTask.MySQLFetch	(		self,
			request
	)

Definition at line 153 of file DBDataTask.py.

  def MySQLFetch(self, request):
    logger.debug(">>> MySQLFetch start")
    ret = dc.EventObjects.DataFetchResponse({})
    if self.queryCallback is not None:
      tableName = Constants.DC_CONTENTS_TABLE_NAME_TEMPLATE % request.siteId
      query = Constants.SELECT_DB_STORAGE % (tableName, request.urlMd5)
      res = self.queryCallback(query, Constants.FIFTH_DB_ID, Constants.EXEC_NAME)
      if hasattr(res, '__iter__') and len(res) >= 1:
        ret.resultDict = res[0]
        for key in ret.resultDict:
          if type(ret.resultDict[key]) == datetime.datetime:
            ret.resultDict[key] = str(ret.resultDict[key])
        # type(insertDict[key]) == datetime.datetime
      else:
        ret.errCode = 1
        ret.errMessage = ">>> empty mysql response"
    return ret

MySQLInsert()

def dc_db.DBDataTask.DBDataTask.MySQLInsert	(		self,
			request
	)

Definition at line 235 of file DBDataTask.py.

  def MySQLInsert(self, request):
    logger.debug(">>> MySQLInsert start")
    ret = dc.EventObjects.URLPutResponse(dc.EventObjects.Content.CONTENT_PROCESSOR_CONTENT)
    if self.queryCallback is not None:
      tableName = Constants.DC_CONTENTS_TABLE_NAME_TEMPLATE % request.siteId
      SQL_CHECK_TABLE = "SELECT count(*) FROM `%s`"
      query = SQL_CHECK_TABLE % tableName
      res = self.queryCallback(query, Constants.FIFTH_DB_ID)
      if res is None or len(res) == 0:
        mySQLCreateTableRequest = dc.EventObjects.DataCreateRequest(request.siteId, None, None)
        self.MySQLCreateTable(mySQLCreateTableRequest)

      query = self.createInsertQueryMySQL(request.putDict, Constants.DbContentFields["MYSQL"], tableName)
      self.queryCallback(query, Constants.FIFTH_DB_ID)
    return ret

Here is the call graph for this function:

process()

def dc_db.DBDataTask.DBDataTask.process	(		self,
			dbDataRequest,
			queryCallback
	)

Definition at line 73 of file DBDataTask.py.

  def process(self, dbDataRequest, queryCallback):
    ret = None
    self.queryCallback = queryCallback
    logger.debug(">>> DBDataTask process")
    if type(dbDataRequest) == dc.EventObjects.DataFetchRequest:
      if self.fetchFunc is not None:
        ret = self.fetchFunc(dbDataRequest)
      else:
        ret = dc.EventObjects.DataFetchResponse({})
    elif type(dbDataRequest) == dc.EventObjects.URLPut:
      if ("id" not in dbDataRequest.putDict or dbDataRequest.putDict["id"] is None) and \
      dbDataRequest.urlMd5 is not None:
        dbDataRequest.putDict["id"] = dbDataRequest.urlMd5
      if "CDate" not in dbDataRequest.putDict or dbDataRequest.putDict["CDate"] is None:
        dbDataRequest.putDict["CDate"] = SQLExpression('CURRENT_TIMESTAMP')
      if dbDataRequest.contentType == dc.EventObjects.Content.CONTENT_PROCESSOR_CONTENT:
        if self.insertFunc is not None:
          ret = self.insertFunc(dbDataRequest)
        else:
          ret = dc.EventObjects.URLPutResponse(dc.EventObjects.Content.CONTENT_PROCESSOR_CONTENT)
      else:
        ret = self.insertFSFunc(dbDataRequest)

      ret.contentType = dbDataRequest.contentType
    elif type(dbDataRequest) == dc.EventObjects.DataDeleteRequest:
      if dbDataRequest.urlMd5 is None:
        self.delTableFunc(dbDataRequest)
      else:
        self.delRecordFunc(dbDataRequest)
    elif type(dbDataRequest) == dc.EventObjects.DataCreateRequest:
      if dbDataRequest.urlMd5 is None:
        self.createTableFunc(dbDataRequest)
      else:
        pass
    else:
      logger.error(">>> Unsupport request object type = " + str(type(dbDataRequest)))
    return ret

Here is the call graph for this function:

Here is the caller graph for this function:

resolveFileSuffix()

def dc_db.DBDataTask.DBDataTask.resolveFileSuffix	(		self,
			contentType
	)

Definition at line 415 of file DBDataTask.py.

  def resolveFileSuffix(self, contentType):
    ret = ""
    if contentType == dc.EventObjects.Content.CONTENT_RAW_CONTENT:
      ret = dc.Constants.RAW_DATA_SUFF
    elif contentType == dc.EventObjects.Content.CONTENT_TIDY_CONTENT:
      ret = dc.Constants.RAW_DATA_TIDY_SUFF
    elif contentType == dc.EventObjects.Content.CONTENT_HEADERS_CONTENT:
      ret = dc.Constants.RAW_DATA_HEADERS_SUFF
    elif contentType == dc.EventObjects.Content.CONTENT_REQUESTS_CONTENT:
      ret = dc.Constants.RAW_DATA_REQESTS_SUFF
    elif contentType == dc.EventObjects.Content.CONTENT_META_CONTENT:
      ret = dc.Constants.RAW_DATA_META_SUFF
    elif contentType == dc.EventObjects.Content.CONTENT_COOKIES_CONTENT:
      ret = dc.Constants.RAW_DATA_COOKIES_SUFF
    elif contentType == dc.EventObjects.Content.CONTENT_DYNAMIC_CONTENT:
      ret = dc.Constants.RAW_DATA_DYNAMIC_SUFF
    elif contentType == dc.EventObjects.Content.CONTENT_CHAIN_PARTS:
      ret = dc.Constants.RAW_DATA_CHAIN_SUFF
    return ret

Member Data Documentation

createTableFunc

dc_db.DBDataTask.DBDataTask.createTableFunc

Definition at line 49 of file DBDataTask.py.

dbDataType

dc_db.DBDataTask.DBDataTask.dbDataType

Definition at line 45 of file DBDataTask.py.

dcContentTemplate

dc_db.DBDataTask.DBDataTask.dcContentTemplate

Definition at line 65 of file DBDataTask.py.

delRecordFunc

dc_db.DBDataTask.DBDataTask.delRecordFunc

Definition at line 54 of file DBDataTask.py.

delTableFunc

dc_db.DBDataTask.DBDataTask.delTableFunc

Definition at line 55 of file DBDataTask.py.

fetchFunc

dc_db.DBDataTask.DBDataTask.fetchFunc

Definition at line 47 of file DBDataTask.py.

insertFunc

dc_db.DBDataTask.DBDataTask.insertFunc

Definition at line 48 of file DBDataTask.py.

keyValueDefaultFile

dc_db.DBDataTask.DBDataTask.keyValueDefaultFile

Definition at line 64 of file DBDataTask.py.

keyValueStorageDir

dc_db.DBDataTask.DBDataTask.keyValueStorageDir

Definition at line 44 of file DBDataTask.py.

NO_DIR_STR

string dc_db.DBDataTask.DBDataTask.NO_DIR_STR = "No such file or directory:"

static

Definition at line 34 of file DBDataTask.py.

queryCallback

dc_db.DBDataTask.DBDataTask.queryCallback

Definition at line 46 of file DBDataTask.py.

rawDataDir

dc_db.DBDataTask.DBDataTask.rawDataDir

Definition at line 43 of file DBDataTask.py.

---

The documentation for this class was generated from the following file:

• sources/hce/dc_db/DBDataTask.py