def _create_table(self): """This step will create the flat and itemized tables""" self.tablenames.append(self.tablename) drop_table_if_exists(self.tablename, self.db) self.logger.info('self.tablename={0}'.format(self.tablenames)) self.logger.info('qry = {0}'.format(self.table.definition)) self.db.executeNoResults(self.table.definition)
def test_valid_mergespec_file_output_format(self): self._log.info( 'test_valid_mergespec_file_output_format() - testing...') valid_ds_input_file = os.path.join(self._run_context.tests_safe_dir, DS_INPUT_FILE_VALID) input_tables = {FLAT_TABLE_KEY_NAME: VALID_DS_INPUT_TABLE_NAME} dbutilities.drop_table_if_exists( db_context=self._run_context.getDBContext(), table=VALID_DS_INPUT_TABLE_NAME) input_table_reader = SafeExcelReader( run_context=self._run_context, filename=valid_ds_input_file, sheet_name=DS_INPUT_FILE_SHEET_VALID, db_context=self._run_context.getDBContext(), output_table=VALID_DS_INPUT_TABLE_NAME) input_table_reader.createTable() mergespec_file = 'C:/{}'.format(MERGESPEC_OUTPUT_FILE) if os.path.exists(mergespec_file): os.remove(mergespec_file) cmpmrg = ComplementaryMerge(run_context=self._run_context) cmpmrg.create_mergespec_file(input_table_names=input_tables, new_mergespec_file=mergespec_file) self._log.info('test_valid_mergespec_file_output_format() - tested.') filename1 = mergespec_file filename2 = os.path.join(self._run_context.tests_safe_dir, COMPARE_FILE_MERGESPEC_OUTPUT) assert filecmp.cmp( filename1, filename2), 'Python test output does not match expected output.'
def _school_intervention(self): print " Create SCHOOL_INTERVENTION_ASCII" self.table_name = 'SCHOOL_INTERVENTION_ASCII' drop_table_if_exists( 'SCHOOL_INTERVENTION_ASCII', self.db) self.db.executeNoResults(sqls['SCHOOL_INTERVENTION']) self.db.executeNoResults("ALTER TABLE SCHOOL_INTERVENTION_ASCII DROP COLUMN DCRXID") self.db.executeNoResults("sp_RENAME 'SCHOOL_INTERVENTION_ASCII.DCRXID_RECODED','DCRXID','COLUMN'")
def _district(self): print " Create DISTRICT_ASCII" self.table_name = 'DISTRICT_ASCII' drop_table_if_exists( 'DISTRICT_ASCII', self.db) self.db.executeNoResults(sqls['DISTRICT']) self.db.executeNoResults("ALTER TABLE DISTRICT_ASCII DROP COLUMN GRADE, RGRADE") self.db.executeNoResults("sp_RENAME 'DISTRICT_ASCII.GRADE_RECODED','GRADE','COLUMN'") self.db.executeNoResults("sp_RENAME 'DISTRICT_ASCII.GRADE_R_RECODED','GRADE_R','COLUMN'")
def _school(self): print " Create SCHOOL_ASCII" self.table_name = 'SCHOOL_ASCII' drop_table_if_exists( 'SCHOOL_ASCII', self.db) self.db.executeNoResults(sqls['SCHOOL']) self.db.executeNoResults("ALTER TABLE SCHOOL_ASCII DROP COLUMN GRADE, RGRADE") self.db.executeNoResults("sp_RENAME 'SCHOOL_ASCII.GRADE_RECODED','GRADE','COLUMN'") self.db.executeNoResults("sp_RENAME 'SCHOOL_ASCII.GRADE_R_RECODED','GRADE_R','COLUMN'")
def _create_table(self): """This step will create the flat and itemized tables""" self.tablenames.append(self.tablename) drop_table_if_exists( self.tablename, self.db) if self.debug: print 'self.tablename=', self.tablenames print 'qry=',self.table.definition self.db.executeNoResults(self.table.definition)
def populate_school_intervention(dbcontext): print " Create SCHOOL_INTERVENTION_ASCII" drop_table_if_exists('SCHOOL_INTERVENTION_ASCII', dbcontext) dbcontext.executeNoResults(sqls['SCHOOL_INTERVENTION']) dbcontext.executeNoResults( "ALTER TABLE SCHOOL_INTERVENTION_ASCII DROP COLUMN DCRXID") dbcontext.executeNoResults( "sp_RENAME 'SCHOOL_INTERVENTION_ASCII.DCRXID_RECODED','DCRXID','COLUMN'" )
def populate_school(dbcontext): print " Create SCHOOL_ASCII" drop_table_if_exists('SCHOOL_ASCII', dbcontext) dbcontext.executeNoResults(sqls['SCHOOL']) dbcontext.executeNoResults( "ALTER TABLE SCHOOL_ASCII DROP COLUMN GRADE, RGRADE") dbcontext.executeNoResults( "sp_RENAME 'SCHOOL_ASCII.GRADE_RECODED','GRADE','COLUMN'") dbcontext.executeNoResults( "sp_RENAME 'SCHOOL_ASCII.GRADE_R_RECODED','RGRADE','COLUMN'")
def main(): """ This runs a test of the complementary_merge wrapper/glue code. """ run_context = SuiteContext('OGT_test{}'.format(RUN_CONTEXT_NUMBER)) log = run_context.get_logger('ComplementaryMerge') db_context = run_context.getDBContext() intermediate_path = 'OGT Fall 2012' if ( SUMMER_OR_FALL == 'F') else 'OGT Spring 2012' # Summer has SAS variables. pathname = os.path.join(CVSROOT, 'CSSC Score Reporting', intermediate_path, 'Code/Development/Intake') bookmap_location_file_name = os.path.join(pathname, BOOKMAP_LOCATION_FILE_NAME) log.debug("main - bookmap_location_file_name[%s]" % bookmap_location_file_name) print("bookmap_location_file_name[%s]" % bookmap_location_file_name) mergespec_file_name = os.path.join(run_context.tests_safe_dir, MERGESPEC_FILE_NAME) input_table_names = { FLAT_TABLE_KEY_NAME: 'rc2FINAL', 'C': 'mc_table_C', 'M': 'mc_table_M', 'R': 'mc_table_R', 'S': 'mc_table_S', 'W': 'mc_table_W' } output_table_names = { FLAT_TABLE_KEY_NAME: 'rc2FINAL_cmrg', 'C': 'mc_table_C_cmrg', 'M': 'mc_table_M_cmrg', 'R': 'mc_table_R_cmrg', 'S': 'mc_table_S_cmrg', 'W': 'mc_table_W_cmrg' } for key in output_table_names: dbutilities.drop_table_if_exists(db_context=db_context, table=output_table_names[key]) try: complementary_merge( run_context=run_context, bookmap_location_file_name=bookmap_location_file_name, bookmap_sheet=BOOKMAP_SHEET, mergespec_file_name=mergespec_file_name, input_table_names=input_table_names, output_table_names=output_table_names) #create_mergespec_file( run_context=run_context, input_table_names=input_table_names, # new_mergespec_file='C:/new_mergespec_file.csv' ) except Exception, error_msg: log.exception('\n\n') raise
def _student(self): print " Create STUDENT_ASCII" self.table_name = 'STUDENT_ASCII' drop_table_if_exists( 'STUDENT_ASCII', self.db) self.db.executeNoResults(sqls['STUDENT']) self.db.executeNoResults("ALTER TABLE STUDENT_ASCII DROP COLUMN GRADE, RGRADE, UFRX_BREACH, UFSX_BREACH, UFWX_BREACH, UFCX_BREACH, UFMX_BREACH") self.db.executeNoResults("sp_RENAME 'STUDENT_ASCII.GRADE_RECODED','GRADE','COLUMN'") self.db.executeNoResults("sp_RENAME 'STUDENT_ASCII.GRADE_R_RECODED','GRADE_R','COLUMN'") self.db.executeNoResults("sp_RENAME 'STUDENT_ASCII.UFRX_BREACH_RECODED','UFRX_BREACH','COLUMN'") self.db.executeNoResults("sp_RENAME 'STUDENT_ASCII.UFMX_BREACH_RECODED','UFMX_BREACH','COLUMN'") self.db.executeNoResults("sp_RENAME 'STUDENT_ASCII.UFWX_BREACH_RECODED','UFWX_BREACH','COLUMN'") self.db.executeNoResults("sp_RENAME 'STUDENT_ASCII.UFSX_BREACH_RECODED','UFSX_BREACH','COLUMN'") self.db.executeNoResults("sp_RENAME 'STUDENT_ASCII.UFCX_BREACH_RECODED','UFCX_BREACH','COLUMN'")
def test_merge_nonfuzzy_norecpriority(self): self._log.info('test_merge_nonfuzzy_norecpriority - testing...') mergespec_file = os.path.join( self._run_context.tests_safe_dir, MERGESPEC_FILE_VALID_NONFUZZY_NORECPRIORITY) valid_ds_input_file = os.path.join(self._run_context.tests_safe_dir, DS_INPUT_FILE_VALID) input_tables = {FLAT_TABLE_KEY_NAME: VALID_DS_INPUT_TABLE_NAME} output_tables = { FLAT_TABLE_KEY_NAME: VALID_DS_OUTPUT_TABLE_NAME_NONFUZZY_NORECPRIORITY } dbutilities.drop_table_if_exists( db_context=self._run_context.getDBContext(), table=VALID_DS_INPUT_TABLE_NAME) dbutilities.drop_table_if_exists( db_context=self._run_context.getDBContext(), table=VALID_DS_OUTPUT_TABLE_NAME_NONFUZZY_NORECPRIORITY) input_table_reader = SafeExcelReader( run_context=self._run_context, filename=valid_ds_input_file, sheet_name=DS_INPUT_FILE_SHEET_VALID, db_context=self._run_context.getDBContext(), output_table=VALID_DS_INPUT_TABLE_NAME) input_table_reader.createTable() cmpmrg = ComplementaryMerge( run_context=self._run_context, flat_table_identity_field_name='[import_order]') cmpmrg.complementary_merge(mergespec_file=mergespec_file, input_table_names=input_tables, output_table_names=output_tables, force_one_only=False) columns_str = ( 'Barcode, ID, LastName, FirstName, Score1, Race, Old, Score2, Score3, Score4, variable_priority,' ' record_priority, Attempt1, Attempt2, Attempt3, Attempt4, iep') filename1 = self._dump_table( VALID_DS_OUTPUT_TABLE_NAME_NONFUZZY_NORECPRIORITY, columns_str=columns_str, sort_column_nbrs=[1, 6, 0]) filename2 = os.path.join(self._run_context.tests_safe_dir, COMPARE_FILE_NONFUZZY_NORECPRIORITY) assert filecmp.cmp( filename1, filename2), 'Python test output does not match SAS test output.' self._log.info('test_merge_nonfuzzy_norecpriority - tested.')
def __init__(self, runcontext, dbcontext, merge_table_1 = " ", merge_table_2 = "", output_table = " ", mergeids = [], drop_columns = [], keep_columns = [] ): self.rc = runcontext self.db = dbcontext self.mergeids = [each.upper() for each in mergeids] self.merge_table_1 = merge_table_1.upper() self.merge_table_2 = merge_table_2.upper() self.drop_columns = [each.upper() for each in drop_columns] self.output_table = output_table.upper() self.common_columns = [] self.keep_columns = [each.upper() for each in keep_columns] self.keep_columns_string = ','.join(self.keep_columns) self.table1_columns = [] self.table2_columns = [] self.table1_columns_nulls = [] self.table2_columns_nulls = [] self.mergeid_ON = [] self.mergeid_ON_fields = '' self.mergeid_WHERE_TB1 = [] self.mergeid_WHERE_TB1_fields = '' self.mergeid_WHERE_TB2 = [] self.mergeid_WHERE_TB2_fields = '' self.mergeid_fields_TB1 = '' self.mergeid_fields_TB2 = '' self.common_columns_fields_TB1 = '' self.common_columns_fields_TB2 = '' self.table1_columns_fields = '' self.table2_columns_fields = '' self.table_columns_fields = '' self.table1_columns_fields_nulls = '' self.table2_columns_fields_nulls = '' self.output_table = output_table drop_table_if_exists( 'SAS_MERGE_1', self.db) drop_table_if_exists( 'SAS_MERGE_2', self.db) drop_table_if_exists( 'SAS_MERGE_3', self.db) drop_table_if_exists(self.output_table, self.db)
def test_mergespec_file_invalid_format(self): self._log.info('test_mergespec_file_invalid_format() - testing...') valid_ds_input_file = os.path.join(self._run_context.tests_safe_dir, DS_INPUT_FILE_VALID) dbutilities.drop_table_if_exists( db_context=self._run_context.getDBContext(), table=VALID_DS_INPUT_TABLE_NAME) dbutilities.drop_table_if_exists( db_context=self._run_context.getDBContext(), table=VALID_DS_OUTPUT_TABLE_NAME) input_table_reader = SafeExcelReader( run_context=self._run_context, filename=valid_ds_input_file, sheet_name=DS_INPUT_FILE_SHEET_VALID, db_context=self._run_context.getDBContext(), output_table=VALID_DS_INPUT_TABLE_NAME) input_table_reader.createTable() mergespec_file = os.path.join(self._run_context.tests_safe_dir, MERGESPEC_FILE_MISSING_COLUMN) input_table_names = {FLAT_TABLE_KEY_NAME: VALID_DS_INPUT_TABLE_NAME} output_table_names = {FLAT_TABLE_KEY_NAME: VALID_DS_OUTPUT_TABLE_NAME} cmpmrg1 = ComplementaryMerge(run_context=self._run_context) with self.assertRaises(EOFError): cmpmrg1.complementary_merge(mergespec_file=mergespec_file, input_table_names=input_table_names, output_table_names=output_table_names, force_one_only=True) mergespec_file = os.path.join(self._run_context.tests_safe_dir, MERGESPEC_FILE_INVALID_COLUMN) cmpmrg2 = ComplementaryMerge(run_context=self._run_context) with self.assertRaises(ValueError): cmpmrg2.complementary_merge(mergespec_file=mergespec_file, input_table_names=input_table_names, output_table_names=output_table_names, force_one_only=True) self._log.info('test_mergespec_file_invalid_format() - tested.') mergespec_file = os.path.join(self._run_context.tests_safe_dir, MERGESPEC_FILE_NO_VARIABLE_PRIORITY) cmpmrg2 = ComplementaryMerge(run_context=self._run_context) with self.assertRaises(ValueError): cmpmrg2.complementary_merge(mergespec_file=mergespec_file, input_table_names=input_table_names, output_table_names=output_table_names, force_one_only=True) self._log.info('test_mergespec_file_invalid_format() - tested.')
def process(self): print 'HandScore_check_module_started' try: for eachlist in subject_col_mapping.values(): drop_table_if_exists(eachlist[5], self.dbcontext) drop_table_if_exists(eachlist[6], self.dbcontext) drop_table_if_exists(eachlist[5] + '_intr', self.dbcontext) drop_table_if_exists(eachlist[6] + '_intr', self.dbcontext) # self._process_sa_items() self._process_er_items() except Exception as error: print 'Error=', error
def test_ds_output_already_exists(self): self._log.info('test_ds_output_already_exists() - testing...') mergespec_file = os.path.join(self._run_context.tests_safe_dir, MERGESPEC_FILE_VALID) valid_ds_input_file = os.path.join(self._run_context.tests_safe_dir, DS_INPUT_FILE_VALID) dbutilities.drop_table_if_exists( db_context=self._run_context.getDBContext(), table=VALID_DS_INPUT_TABLE_NAME) input_table_reader = SafeExcelReader( run_context=self._run_context, filename=valid_ds_input_file, sheet_name=DS_INPUT_FILE_SHEET_VALID, db_context=self._run_context.getDBContext(), output_table=VALID_DS_INPUT_TABLE_NAME) input_table_reader.createTable() input_table_names = {FLAT_TABLE_KEY_NAME: VALID_DS_INPUT_TABLE_NAME} output_table_names = {FLAT_TABLE_KEY_NAME: VALID_DS_INPUT_TABLE_NAME} cmpmrg = ComplementaryMerge(run_context=self._run_context) with self.assertRaises(IOError): cmpmrg.complementary_merge(mergespec_file=mergespec_file, input_table_names=input_table_names, output_table_names=output_table_names) self._log.info('test_ds_output_already_exists() - tested.')
def test_21(self): answer_dir = os.path.join(self.answer_dir, 'test_21') if not os.path.exists(answer_dir): os.makedirs(answer_dir) specimen_dir = os.path.join(self.specimen_dir, 'ttest_test_21') result = True with self.read_g3() as g3, \ self.read_oat_agg_sheet() as agg_sheet, \ dbutilities.get_temp_table( self.db_context ) as tmp, \ dbutilities.get_temp_table( self.db_context ) as tmp_agg : # As near as I can tell, the SAS test only runs for the tenth row of the agg sheet. # self.db_context.executeNoResults("DELETE FROM {agg_sheet} WHERE [import_order] != 10".format( agg_sheet=agg_sheet )) # We are just using this TTest instance to read the aggregation sheet. The actual ttest will use # another instance based on a truncated aggregation sheet. agg_sheet_reader = TTest(g3, self.db_context, agg_sheet, None, False) agg_sheet_reader.readAggData() assert dbutilities.table_exists(g3) targetParentRow = [] for target_level in agg_sheet_reader.target_levels: for parent_level in target_level.contents: for row in parent_level.contents: targetParentRow.append( (target_level, parent_level, row)) targetParentRow.sort(key=lambda (row): row[2].import_order) for target_level, parent_level, row in targetParentRow: where_t = target_level.get_where_expression() target_id = target_level.id where_p = parent_level.get_where_expression() parent_id = parent_level.id i = row.import_order # Reduce the data to the desired sample dbutilities.drop_table_if_exists(tmp) query = """ SELECT {vars}, COUNT( {input_var} ) OVER( PARTITION BY {parent_id}, {target_id} ) AS n_target, 0 AS n_parent INTO {tmp} FROM {g3} WHERE {where_t} """.format(parent_id=parent_id, target_id=target_id, input_var=row.inputvar, where_t=where_t, tmp=tmp, g3=g3, vars=Joiner(g3)) self.db_context.executeNoResults(query) query = """ UPDATE {tmp} SET n_parent = A.B FROM ( SELECT n_parent, COUNT( {input_var} ) OVER( PARTITION BY {parent_id} ) AS B FROM {tmp} WHERE {where_p} ) AS A """.format(parent_id=parent_id, input_var=row.inputvar, where_p=where_p, tmp=tmp) print query self.db_context.executeNoResults(query) query = "DELETE FROM {tmp} WHERE ( n_parent != 2 ) OR ( n_target != 1 )".format( tmp=tmp) self.db_context.executeNoResults(query) n_obs = dbutilities.n_obs(tmp) if n_obs > 0: # Reduce the aggregation sheet to the current row query = "SELECT * INTO {tmp_agg} FROM {agg_sheet} WHERE [import_order]={i}".format( tmp_agg=tmp_agg, agg_sheet=agg_sheet, i=i) self.db_context.executeNoResults(query) # Do the ttest ttester = TTest(tmp, self.db_context, tmp_agg, None, False) ttester.readAggData() ttester.execute() # Check the answer answer_file = os.path.join( answer_dir, 'row_{0}_comparison.log'.format(i)) specimen_file = os.path.join( specimen_dir, 'test_21_ttest_{0}.xls'.format(i)) result_i = self.compare_output(specimen_file, target_level, answer_file) result = result and result_i print "{1} ttest test_21 for {0}".format( i, 'PASSED' if result_i else 'FAILED') self.assertTrue(result, "TTest Test 21 FAILED") return
def _districtnames(self): print " Create DISTRICTNAMES_ASCII" self._alldistricts() self.table_name = 'DISTRICTNAMES_ASCII' drop_table_if_exists( 'DISTRICTNAMES_ASCII', self.db) self.db.executeNoResults(sqls['DISTRICTNAMES'])
def populate_districtnames(dbcontext): print "Create DISTRICTNAMES_ASCII" drop_table_if_exists('DISTRICTNAMES_ASCII', dbcontext) dbcontext.executeNoResults(sqls['DISTRICTNAMES'])
def _alldistricts(self): """ This is a temporary table referred while creating the alldistricts table""" print " Create ALLDISTRICTS_ASCII" self.table_name = 'ALLDISTRICTS_ASCII' drop_table_if_exists( 'ALLDISTRICTS_ASCII', self.db) self.db.executeNoResults(sqls['ALLDISTRICTS'])
def _school_intervention_jd(self): print " Create SCHOOL_INTERVENTION_JD_ASCII" self.table_name = 'SCHOOL_INTERVENTION_JD_ASCII' drop_table_if_exists( 'SCHOOL_INTERVENTION_JD_ASCII', self.db) self.db.executeNoResults(sqls['SCHOOL_INTERVENTION_JD'])
def __init__(self, runcontext, dbcontext, layoutfile='', inputfile='', patterns=[], OEpatterns=[], flat_tablename='', debug=False, bulk_insert=True, errorfile='', outputsdir='c:/SAS/OGT/Joboutput/', table_names='TABLE_NAMES', output_table='Layout_Temp', lock=None, batchfile='bcpfile.bat', row_count=1): """This is the intialization step and it needs the following inputs to run runcontext = creates the logger methods dbcontext = creates the db connection objects layoutfile = layoutfile that will be this process inputfile = inputfile that will be this process pattern = pattern to identify the MC item fields OEpattern = pattern to identify the OE item fields flat_tablename = The flat tablename that will be created debuf = FALSE(default), this will print all the debug messages in the console bulk_insert = Indicator to specify to perform bulk inserts errorfile = This file will contain all the errors while processing outputsdir = All the outputs will be listed in this directory, If the directory does not exists it will be created. """ self.lock = lock self.output_table = output_table self.RC = runcontext self.db = dbcontext self.logger = self.RC.get_logger("preqc") self.layoutfile = layoutfile self.inputfile = inputfile self.errorfile = errorfile self.outputrec = {} self.layoutdict = [] self.maxmindict = [] self.recodingsdict = {} self.reset_counter = 1 self.patterns = patterns self.OEpatterns = OEpatterns self.OE_items_tables_collist = [] self.OE_items_pos_tables_collist = [] self.mc_items_tables_collist = [] self.mc_items_table_names = [] self.mc_items_table_field_names = {} self.item_tables_columns = [] self.all_columns = [] self.tablename = '' self.item_table = False self.debug = debug #Missing_column should be a Ordereddict as we need to add the MISSING Columns self.missing_columns = OrderedDict() self.tablenames = [] self.column_names = [] self.flat_tablename = flat_tablename self.bulkinsert = bulk_insert self.bulk_insert_list = [] self.row_count = row_count self.t1 = datetime.datetime.now() self.t2 = datetime.datetime.now() if not os.path.exists(outputsdir): os.makedirs(outputsdir) self.f = open('c:/OGTValidation.txt', "w") self.error_file = open(self.errorfile, 'w') self.insert_rows = [] self.file_lists = [] self.field_ind = 0 self.outputs_dir = outputsdir self.pre_flat_qc_table_file = open( self.outputs_dir + self.flat_tablename + '.txt', 'w') self.batchfilename = batchfile self.batchfile = open(self.outputs_dir + batchfile, 'w') self.statsfile = open(self.outputs_dir + 'loadstats.txt', 'w') open(self.outputs_dir + 'error.txt', 'w') batch_file_string = 'bcp ' + self.db.db + '.dbo.' + self.flat_tablename + ' in ' + self.outputs_dir + self.flat_tablename + '.txt' \ + ' -t "&!!" -c -S ' + self.db.server + ' -T -e ' + self.outputs_dir + 'error.txt' self.batchfile.write(batch_file_string + '\n') qry = "CREATE TABLE " + table_names + " (subject_id char(5),tablename nvarchar(50) )" drop_table_if_exists(table_names, self.db) self.db.executeNoResults(qry) i = 0 for each in self.patterns: qry = "Insert into " + table_names + " values ('{0}','{1}')".format( each[4], each[3]) self.db.executeNoResults(qry) i += 1 qry = "Insert into " + table_names + " values ('{0}','{1}')".format( 'F', self.flat_tablename) self.db.executeNoResults(qry)
def sql_2(dbcontext): print ' dbcontext executing_2 = ', dbcontext drop_table_if_exists( 'employee_2_test', dbcontext) dbcontext.executeNoResults("select * into employee_2_test from employee1")
def _housekeeping(self): qry = "CREATE TABLE FILE_CONTROL_TABLE (id int,FILENAME nvarchar( 100) )" drop_table_if_exists('FILE_CONTROL_TABLE', self.db) self.db.executeNoResults(qry) print 'Housekeeping done'
def _allschools_jd(self): print " Create ALLSCHOOLS_JD_ASCII" self.table_name = 'ALLSCHOOLS_JD_ASCII' drop_table_if_exists( 'ALLSCHOOLS_JD_ASCII', self.db) self.db.executeNoResults(sqls['ALLSCHOOLS_JD'])
def _studenthomedistrict(self): print " Create STUDENTHOMEDISTRICT_ASCII" self.table_name = 'STUDENTHOMEDISTRICT_ASCII' drop_table_if_exists( 'STUDENTHOMEDISTRICT_ASCII', self.db) self.db.executeNoResults(sqls['STUDENTHOMEDISTRICT'])