def make_interpreter(src):
lexer = Lexer(src)
parser = Parser(lexer)
tree = parser.parse()
interpreter = Interpreter(tree)
return interpreter
def cogitation(self):
""" Papy will fill the following fields :
- palce
- location
- maps
- wiki """
parser = Parser(self.question)
self.place = parser.get_place()
if self.place:
maps_api = MapsApi(self.place)
wiki_api = WikiApi(self.place)
self.location = maps_api.get_location()
self.wiki = wiki_api.get_wiki()
if not self.location:
self.errors.append("NO_LOCATION")
if not self.wiki:
self.errors.append("NO_WIKI")
else:
self.errors.append("BAD_QUESTION")
self.location = None
self.wiki = [None, None]
class AnimationModel:
def __init__(self):
self.parser = Parser()
self.width = 0
self.height = 0
self.frames_num = 0
self.current_frame = 0
self.file_path = ""
self.is_meta_loaded = False
def set_file_path(self, file_path):
self.file_path = file_path
self.parser.set_file(self.file_path)
def get_info(self):
self.width, self.height, self.frames_num = self.parser.read_animation_info(
)
self.current_frame = 1
self.is_meta_loaded = True
def get_frame(self):
frame = None
if self.is_meta_loaded:
frame = self.parser.read_frame(
self.width, self.height, self.current_frame == self.frames_num)
if self.current_frame == self.frames_num:
self.current_frame = 1
else:
self.current_frame += 1
return frame
def __init__(self):
self.parser = Parser()
self.width = 0
self.height = 0
self.frames_num = 0
self.current_frame = 0
self.file_path = ""
self.is_meta_loaded = False
def main():
text = open('file2.py', 'r').read()
lexer = Lexer(text)
parser = Parser(lexer)
tree = parser.parse()
interpreter = Interpreter(tree)
interpreter.interpret()
def parse():
# parse gathered data and save as csv
logger.info("parse")
scrapper = Scraper(Persistor)
parser = Parser()
raw_data = scrapper.scrape()
data = []
for raw in raw_data:
data = scrapper.append_data(data, raw)
parsed_files = [parser.parse_object(file) for file in data]
scrapper.save_csv(parsed_files)
def run(self):
sleep(3)
turn = 1
while True:
is_white = bool(turn % 2)
moved = False
final_move = None
try:
data_bytes = self.conn.recv(0 if is_white else 1, 3)
if data_bytes:
client_turn, move = Parser.decode(data_bytes)
if client_turn == turn:
if self.wm.check_move(move, is_white):
moved = True
final_move = move
except Exception as err:
print (err)
if not moved:
print ('random move')
moves = self.wm.all_moves(is_white)
if len(moves):
final_move = choice(moves)
self.wm.do_move(final_move, is_white)
self.conn.send2all(Parser.encode(turn, final_move))
print (self.wm)
w, b = self.wm.result()
if w + b == 64:
if w > b:
print ('White wins!')
elif w < b:
print ('Black wins!')
else:
print ('Draw!')
break
turn += 1
sleep(1)
sleep(6)
self.conn.disconnect()
def parse():
logger.info("parse")
storage = Persistor(SCRAPPED_FILE)
parser = Parser()
raw_data = storage.read_raw_data()
ind_start = raw_data.find('table class=\"wikitable sortable\"')
raw_data = raw_data[ind_start:]
ind_end = raw_data.find('</table>')
raw_data = raw_data[:ind_end + len('</table>')]
all_rows = re.findall('<tr[^^]*?</tr>', raw_data)
parsed_files = [parser.parse_object(raw) for raw in all_rows]
storage.save_csv(parsed_files, TABLE_FORMAT_FILE)
def __init__(self):
self.terminate_map = {}
for k, v in Param.terminate_pair.items():
self.terminate_map[v] = k
#self.trie = self._constructTrie()
#self.parser = Parser(self.trie)
self.db = {}
self.currentDB = 'defaultdb'
self.tables = {}
'''
self.tables['Employee'] = <'Table' object at ...>
self.tables['Company'] = <'Table' object at ...>
'''
self.parser = Parser()
self.head_lines = 5
self.printall = False
self.return_time = False
def __init__(self, string):
self.orx = 0.0
self.ory = 0.0
self.scx = 1.0
self.scy = 1.0
self.ang = 0.0
self.Draw_color = 'k'
statements = Parser(string)
# print(len(statements))
self.analyse(statements)
self.showPic()
def calc(self):
tokenizer = Tokenizer(self.strcalc)
tokenizer.tokenize()
tokens = tokenizer.get_tokens()
parser = Parser(tokens)
parser.parse()
parser.calc()
self.ans = parser.get_ans()
def main():
print('Welcome to IPOL interpreter!')
# returns lines of string containing the cleaned code
file_reader = FileReader()
# tabs removed, double spaces removed
lines = file_reader.read_file()
tokenizer = Tokenizer()
# returns a 2d list containing the tokens per line of code
tokens_list = tokenizer.tokenize(lines)
tokens_list_copy = tokens_list.copy()
# create instance of the parser with the syntax declared in Syntax class
parser = Parser(syntax=Syntax().get_syntax())
# iterate each line of the list containing the tokens
for line in tokens_list:
recursive_parse(parser, line, callback)
# create a new instance of the parser now with the syntax for recuding operations to expressions
parser = Parser(syntax=Syntax().get_final_syntax())
# Parse to an expression to see if it is valid
for line in parsed_list:
recursive_parse(parser, line, callback1)
exception_checker = ExceptionCheker()
for i in range(len(final_parsed_list)):
# there must be a syntax error because it cannot be converted to a single statement
# check which kind of exception it is
if len(final_parsed_list[i]) > 1:
exception = exception_checker.check_exception(
final_parsed_list[i], i)
if isinstance(exception, IpolException):
exceptions.append(exception)
# now check if the overall structure of the code is valid
# check if there are unused values
# for index, token in enumerate(reduce(final_parsed_list)):
# if token.type == Type.NUMBER or token.type == Type.STR:
# exceptions.append(IpolException(
# ExceptionType.UNUSED_VALUE_ERROR, None, index))
# print exceptions if there are any and halt the build process
if len(exceptions) > 0:
for exception in exceptions:
exception.print()
return
else:
# create a new instance of the parser now with the syntax of the overall ipol code
parser = Parser(syntax=Syntax().get_ipol_syntax())
# finally, verify that the full code is valid
reduced_final_parsed_list = reduce(final_parsed_list)
# recursive_parse(parser, reduced_final_parsed_list, callback2)
reduced_final_parsed_list[:] = (token for token in reduced_final_parsed_list \
if token.type != Type.EMPTY_LINE)
recursive_parse(parser, reduced_final_parsed_list, callback2)
for line in ipol_code_verified:
for token in line:
print(token.type)
# check syntax in class Syntax
# Type.E means accepted
build_failed_message = 'Build Failed.'
try:
if ipol_code_verified[0][0].type == Type.E:
print('Build Successful\n')
else:
print(build_failed_message)
return
except:
print(build_failed_message)
return
# there are no exceptions
# continue with code generation
tokens_list_copy.pop(0)
tokens_list_copy.pop(len(tokens_list_copy) - 1)
generated_code = CodeGenerator().generate(tokens_list_copy)
# this may return a bool data type
if isinstance(generated_code, list):
runnable_code = '\n'.join(generated_code)
runnable_code = runnable_code.replace('&n0', '')
# run the generated python code
with open('ic.py', '+w') as ic:
ic.write(runnable_code)
print('\nBuild Complete.\nView logs on ipol_logs.txt\nView generated code on ic.py\n')
exec(runnable_code, globals())
with open('ipol_logs.txt', '+w') as logs:
text_to_write = 'PARSING LOGS\n\nGENERATED TOKENS\n'
for line in tokens_list:
for token in line:
text_to_write = text_to_write + '{} -> {}'.format(token.type, token.val) + ", "
text_to_write = text_to_write + '\n'
text_to_write = text_to_write + '\PARSED AS...\n'
for line in parsed_list:
for token in line:
text_to_write = text_to_write + str(token.type) + ', '
text_to_write = text_to_write + '\n'
text_to_write = text_to_write + '\nGENERATED INTERMEDIATE CODE\n' + runnable_code
logs.write(text_to_write)
# if bool is returned, that means there was something wrong with the ipol code
else:
print('Build failed')
from lexer import Lexer
from myparser import Parser
from codegen import CodeGen
fname = "helloworld.c"
with open(fname) as f:
text_input = f.read()
lexer = Lexer().get_lexer()
tokens = lexer.lex(text_input)
codegen = CodeGen()
module = codegen.module
builder = codegen.builder
printf = codegen.printf
pg = Parser(module, builder, printf)
pg.parse()
parser = pg.get_parser()
parser.parse(tokens).eval()
codegen.create_ir()
codegen.save_ir("output.ll")
from mylexer import Lexer from myparser import Parser from mypainter import Painter import os textBox = None str = 'FOR T FROM 0 TO 2*PI STEP PI/50 DRAW (cos(T),sin(T));' Lexer(str, show=True) Parser(str, show=True) Painter(str)
from trie import Trie
from myset import MySet
import AdjMatGraph
import os
from myparser import Parser
parser = Parser()
g = AdjMatGraph.AdjGraph()
vidjeno_strana = 0
step = 5
broj_strana = step
poslednja_pretraga = ''
direktorijum = ''
trie = Trie()
final_arr = []
def unosDirektorijuma():
while True:
try:
global direktorijum
direktorijum = input(
"Unesite absolutnu putanju do direktorijuma ili broj 1 za trenutni direktorijum: \n"
)
if direktorijum == '1':
direktorijum = os.getcwd()
break
def test_get_place_bad_question(self):
""" If the question have not place, Parser will raise an error """
parser = Parser(self.BAD_QUESTION)
assert parser.get_place() == None
def callParser():
str = textBox.get('1.0', "end")
# Parser(string, show=False)
# show=True显示分析过程
Parser(str, show=True)
from scanner import Scanner, Token, TokenID
from myparser import Parser
from statSem import *
from compfs import *
parser = Parser("file")
tree = parser.GetTree()
parser.PrintTree(tree, 0)
stack = statSem(tree, Stack())
asm = ASM("file.asm",tree, stack.ids)
asm.run()
asm.file.close()
i = 1
#7/14/2018
import sys
from myparser import Parser
from symbol_table import SymbolTable
from code import Code
file_path = sys.argv[1]
print('#######')
print(file_path)
#should accept a command line arguments specifying the path to the file you want to assemble
print('Running the assembler...')
#open the .asm file for reading
asm = Parser(file_path + '.asm')
#open another file for writing
hack = open(file_path + '.hack', 'w')
#advance all the way through the file once and collect all the symbols (only the psudo symbols?)
symbol_table = SymbolTable()
l_command_address = 0
#a_command_set = set()
a_command_list = []
while asm.hasMoreCommands():
def test_init(self):
""" Init Parser with the question """
parser = Parser(self.GOOD_QUESTION)
assert type(parser.question) == type(self.GOOD_QUESTION)
items = ['get_company_name','get_company_short_description','get_company_description','get_homepage',
'get_sector','get_founded','get_business_model','get_amount_raised','get_funding_stage',
'get_employees','get_products','get_product_stage','get_tags','get_address','get_offices_abroad',
'get_geographical_markets','get_target_markets','get_patent','get_tim_member_1','get_tim_member_2',
'get_tim_member_3','get_funding_round_type','get_funding_round_sum','get_funding_round_investor',
'get_funding_rounds_date','get_funding_round_type_1','get_funding_round_sum_1','get_funding_round_investor_1',
'get_funding_rounds_date_1','get_facebook','get_twitter','get_linkedin','get_url_source','get_similar_link']
with open('urls.txt', 'r') as in_file, open('combined_file.csv', 'w') as outcsv, open('log_file.log', 'w') as log_file:
writer = csv.writer(outcsv)
writer.writerow(title)
for i, url in enumerate(in_file.readlines()):
try:
parser = Parser(url)
result = []
log = str(i) + ' parse page: ' + url
print log
log_file.write(log+'')
for item in items:
to_call = getattr(parser, item)
call = to_call()
if isinstance(call,tuple):
for v in call:
result.append((v or '-'))
else:
result.append((call or '-'))
log_file.write('Done ' +'\n\n')
except Exception, e:
print e
class Core:
DUMP_DUMPALL = 0
def __init__(self):
self.terminate_map = {}
for k, v in Param.terminate_pair.items():
self.terminate_map[v] = k
#self.trie = self._constructTrie()
#self.parser = Parser(self.trie)
self.db = {}
self.currentDB = 'defaultdb'
self.tables = {}
'''
self.tables['Employee'] = <'Table' object at ...>
self.tables['Company'] = <'Table' object at ...>
'''
self.parser = Parser()
self.head_lines = 5
self.printall = False
self.return_time = False
# W
def _constructTrie(self):
trie = Trie()
# Written in multiple lines instead of loop to prevent dealing with hashing
trie.insertList(
tuple(
map(lambda x: x.lower(), [
str(member)
for name, member in lh.SQLKeyword.__members__.items()
])), self.terminate_map['Keyword'])
trie.insertList(
tuple(
map(lambda x: x.lower(), [
str(member)
for name, member in lh.SQLFunction.__members__.items()
])), self.terminate_map['Function'])
trie.insertList(
tuple(
map(lambda x: x.lower(), [
str(member)
for name, member in lh.SQLDataType.__members__.items()
])), self.terminate_map['DataType'])
trie.insertList(
tuple(
map(lambda x: x.lower(), [
str(member)
for name, member in lh.SQLOperator.__members__.items()
])), self.terminate_map['Operator'])
return trie
def _dump_db(self, file_path: str):
new_db = DB(self.currentDB)
new_db.tables = self.tables
self.db[self.currentDB] = new_db
f = open(file_path, 'wb')
pickle.dump(self.db[self.currentDB], f)
f.close()
return 0
def _load_db(self, file_path: str):
with open(file_path, 'rb') as f:
db_f = pickle.load(f)
self.db[db_f.name] = db_f
return 0
def get_table(self, s: str):
if s in self.tables:
return self.tables[s]
elif s.lower() in self.tables:
return self.tables[s.lower()]
elif s.upper() in self.tables:
return self.tables[s.upper()]
else:
return False
@staticmethod
def get_table_from_dict(s: str, d: dict):
if s in d:
return d[s]
elif s.lower() in d:
return d[s.lower()]
elif s.upper() in d:
return d[s.upper()]
else:
return False
def handler(self, s: str):
if self.return_time:
t = time.time()
if ';' in s:
s = s.split(';')
else:
s = [s]
for i in s:
try:
d = self.parser.parse(i)
except:
PrintException.handlerError()
return
if d['type'] == 'select':
if self.printall:
self.execute_select(d).formatout()
else:
self.execute_select(d).head(self.head_lines)
elif d['type'] == 'delete':
self.execute_delete(d)
elif d['type'] == 'insert':
self.execute_insert(d)
elif d['type'] == 'create_db':
self.execute_create_db(d)
elif d['type'] == 'drop_db':
self.execute_drop_db(d)
elif d['type'] == 'create_table':
self.execute_create_table(d)
elif d['type'] == 'drop_table':
self.execute_drop_table(d)
elif d['type'] == 'create_index':
self.execute_create_index(d)
elif d['type'] == 'drop_index':
self.execute_drop_index(d)
elif d['type'] == 'use_db':
self.execute_use_db(d)
else:
PrintException.handlerError()
if self.return_time:
print('Executing queries takes %s seconds.' % (time.time() - t))
def execute_select(self, d: dict):
'''
d = {
'query': {
'select': {
'columns': ['a1', 'A2.c'],
'aggr_func': [],
'distinct': [],
},
'from': ['A1', 'A2', 'B1'],
'where': {
'joins': [['A1.a', '=', 'A2.b'], ['A1.a', '>', 'B1.b']],
'conditions': [['AND', ['A1.a', '>', '2']], ['OR', ['B1.b', '=', '5']]]
},
'groupby': [],
'orderby': [['A1.a'], True],
},
'tables': {
'A1': 'T',
'A2': 'T',
'B1': 'K',
},
'columns': {
'a1': 'A1.a',
'A2.c': 'A2.c',
},
}
'''
query = d['query']
columns = d['columns']
alias_table = d['tables']
# MODIFY THIS!!!
runtime_dict = deepcopy(self.tables)
# ^^^^
for name, subquery in d['subquery'].items():
runtime_dict[name] = self.execute_select(
self.parser.parse_tokens(subquery))
joins = query['where']['joins']
conditions = query['where']['conditions']
select = query['select']
if len(query['groupby']) > 0:
groupby = query['groupby']
else:
groupby = None
if len(query['orderby']) > 0:
orderby = query['orderby']
else:
orderby = None
if len(joins) == 0:
# If there is no join, we can assume there is only one table!
target = d['tables'][query['from'][0]]
final_table = self.get_table_from_dict(target, runtime_dict)
#final_table.printall()
for i in joins:
'''
Sample: i = ['A1.a', '=', 'A2.b']
'''
#print('\n', i, '\n')
v1, operator, v2 = i[0].split('.'), i[1], i[2].split('.')
t1 = alias_table[v1[0]]
t2 = alias_table[v2[0]]
flag_t1_unmodified = False
flag_t2_unmodified = False
if isinstance(t1, str):
t1 = deepcopy(self.get_table_from_dict(t1, runtime_dict))
flag_t1_unmodified = True
if isinstance(t2, str):
t2 = deepcopy(self.get_table_from_dict(t2, runtime_dict))
flag_t2_unmodified = True
if not flag_t1_unmodified:
c1 = i[0]
else:
c1 = v1[1]
if not flag_t2_unmodified:
c2 = i[2]
else:
c2 = v2[1]
# Assign alias
t1.name = v1[0]
t2.name = v2[0]
#print(t1.name, c1, t2.name, c2, v1, operator, v2)
if flag_t1_unmodified and flag_t2_unmodified:
ret_table = t1._join(
t2, [c1, operator, c2],
override_colname=Table.OVERRIDE_COLNAME_BOTH)
elif (not flag_t1_unmodified) and flag_t2_unmodified:
ret_table = t1._join(
t2, [c1, operator, c2],
override_colname=Table.OVERRIDE_COLNAME_LAST)
elif flag_t1_unmodified and (not flag_t2_unmodified):
ret_table = t1._join(
t2, [c1, operator, c2],
override_colname=Table.OVERRIDE_COLNAME_FIRST)
else:
ret_table = t1._join(
t2, [c1, operator, c2],
override_colname=Table.OVERRIDE_COLNAME_NONE)
# Replace A1, A2 with A1 JOIN A2
alias_table[v1[0]] = ret_table
alias_table[v2[0]] = ret_table
# Assume the last join will return the full joined table (?)
final_table = ret_table
#print(alias_table)
#final_table.printall()
if final_table == -1:
raise Exception('')
T, cur_table = final_table, final_table
#Sample: i = ['AND', ['A1.a', '>', '3']]
for i in conditions:
junction, condition = i[0], i[1]
condition[2] = float(condition[2])
if junction.upper() == 'AND':
cur_table = cur_table._project(condition)
else:
new_t = T._project(condition)
cur_table = cur_table._union(new_t)
if select['aggr_func']:
aggr_func = select['aggr_func'][0]
else:
aggr_func = select['aggr_func']
if len(aggr_func) == 0:
aggr_func = None
else:
aggr_func[1] = d['columns'][aggr_func[1]]
distinct = select['distinct']
if len(distinct) == 0:
distinct = None
#cur_table.printall()
#print(columns, aggr_func)
if select['columns'] == ['*']:
columns = cur_table._col_names
else:
columns = [d['columns'][i] for i in select['columns']]
if cur_table == -1:
raise Exception('')
cur_table = cur_table._select(columns,
distinct=distinct,
aggr_func=aggr_func,
orderby=orderby,
groupby=groupby)
reverse_columns_name_map = {}
for k, v in d['columns'].items():
reverse_columns_name_map[v] = k
cur_table._col_names = list(
map(
lambda x: reverse_columns_name_map[x]
if x in reverse_columns_name_map else x, cur_table._col_names))
return cur_table
def execute_delete(self, d):
'''
DELETE FROM Employees
WHERE A = 1
d = {
'from': 'Employees',
'where': ['A', '=', '1']
}
'''
if self.get_table(d['from']):
target = self.get_table(d['from'])
if target._foreign_key:
# A.a REFERENCES B.b
# B._foreign_key = [['b', 'A', 'a', self.ONDELETE_CASCADE]]
for fk in target._foreign_key:
target_c, ref_t, ref_c, fk_policy = fk[0], self.get_table(
fk[1]), fk[2], fk[3]
if len(target_c) == 1:
target_c = target_c[0]
if len(ref_c) == 1:
ref_c = ref_c[0]
target_fk_loc = target._col_names.index(target_c)
ref_fk_loc = ref_t._col_names.index(ref_c)
to_d = target._delete(d['where'][0][1], try_d=True)
if fk_policy == Table.ONDELETE_NOACTION or fk_policy == Table.ONDELETE_RESTRICT:
for _, v in ref_t._tuples.items():
for j in to_d:
if v[ref_fk_loc] == j[target_fk_loc]:
return -1
elif fk_policy == Table.ONDELETE_CASCADE:
del_list = []
for k, v in ref_t._tuples.items():
for j in to_d:
if v[ref_fk_loc] == j[target_fk_loc]:
del_list.append(k)
for i in del_list:
ref_t._tuples.pop(i)
elif fk_policy == Table.ONDELETE_SETNULL:
del_list = []
for k, v in ref_t._tuples.items():
for j in to_d:
if v[ref_fk_loc] == j[target_fk_loc]:
del_list.append(k)
for i in del_list:
ref_t._tuples[i][ref_fk_loc] = None
target._delete(d['where'][0][1])
else:
target._delete(d['where'][0][1])
else:
raise Exception('')
return 0
def execute_update(self, d):
'''
UPDATE Employees
SET A = 1, B = 'a'
WHERE C = 5
d = {
'update': 'Employees',
'set': [['A', 1], ['B', 'a']]
'where': ['C', '=', 5]
}
'''
if self.get_table(d['update']):
target = self.get_table(d['update'])
target._update(d['set'], d['where'])
def execute_insert(self, d):
'''
INSERT INTO Employees
VALUES (1, 2, 3)
d = {
'insert_into': 'Employees',
'values': [(1, 2, 3), (4, 5, 6)]
}
'''
if self.get_table(d['insert_into']):
target = self.get_table(d['insert_into'])
vals = d['values']
return target._insert(tuple(vals))
else:
raise Exception('')
return 0
def execute_create_db(self, d):
'''
CREATE DATABASE testdb;
d = {
'name': 'testdb',
}
'''
if not d['name'] in self.db:
self.db[d['name']] = DB(d['name'])
return 0
else:
raise Exception('')
def execute_use_db(self, d):
'''
USE testdb;
d = {
'name': 'testdb',
}
'''
if d['name'] in self.db:
if self.tables:
# Save to old db
self.db[self.currentDB].updateTable(self.tables)
# Go to new db
self.currentDB = d['name']
self.tables = self.db[d['name']].tables
else:
raise Exception('')
return 0
def execute_drop_db(self, d):
'''
d = {
'name': 'testdb',
}
'''
if d['name'] in self.db:
if d['name'] == self.currentDB:
self.currentDB = None
self.tables = {}
self.db.pop(d['name'])
else:
raise Exception('')
return 0
def execute_create_index(self, d):
'''
{
'name': index_name,
'table': table_name,
'columns': []
}
'''
if self.get_table(d['table']):
t = self.get_table(d['table'])
for col in d['columns']:
t._create_index(d['name'], col)
else:
raise Exception('')
return 0
def execute_drop_index(self, d):
'''
{
'table': table_name,
'index': index_name
}
'''
if self.get_table(d['table']):
self.get_table(d['table'])._drop_index(d['index'])
else:
raise Exception('')
return 0
def execute_create_table(self, d):
'''
d = {
'name': 'Employees',
'col_names': ['A', 'B', 'C'],
'dtype': ['int', 'varchar', 'date'],
'primary_key': ['A'],
'foreign_key': ['B', 'Company', 'A', 'CASCADE'],
}
If not specified, the last field in d['foreign_key'] can be None.
'''
fks = []
for fk in d['foreign_key']:
if len(fk) == 4:
if not fk[3] or fk[3] == 'NOACTION':
fks.append([fk[0], fk[1], fk[2], Table.ONDELETE_NOACTION])
elif fk[3] == 'CASCADE':
fks.append([fk[0], fk[1], fk[2], Table.ONDELETE_CASCADE])
elif fk[3] == 'SETNULL':
fks.append([fk[0], fk[1], fk[2], Table.ONDELETE_SETNULL])
else:
raise Exception
else:
raise Exception('')
return self._create_table(d['name'], d['col_names'], d['dtype'],
d['primary_key'], fks)
def execute_drop_table(self, d):
'''
d = {
'name': 'Employees',
'if_exist': False,
}
'''
return self._drop_table(d['name'], False)
def _create_table(self,
name: str,
col_names: list,
dtype: list,
primary_key=None,
foreign_key=None) -> int:
'''
e.g.
CREATE TABLE Employees (
A int,
B varchar(255),
C date,
PRIMARY KEY (A),
FOREIGN KEY (B) REFERENCES Company(A) ON DELETE CASCADE
)
is accepted as _create_table('Employees', ['A, 'B', 'C'], ['int', 'varchar', 'date'], primary key = 'A', foreign_key = ['B', 'Company', 'A', Table.ONDELETE_CASCADE]).
If not specified, the on_delete parameter is set to Table.ONDELETE_NOACTION
'''
if name in self.tables:
PrintException.keyError('_create_table')
return -1
if foreign_key:
for key in foreign_key:
target = key[1]
fk = [key[2], name, key[0], key[3]]
if target in self.tables:
self.get_table(target)._addForeignKeyConstraint(fk)
else:
PrintException.keyError()
return -1
self.tables[name] = Table.createTable(name,
col_names=col_names,
dtype=dtype,
primary_key=primary_key)
return 0
def _drop_table(self, table_name, if_exist=False):
if not self.get_table(table_name):
if if_exist:
return 0
else:
PrintException.keyError()
return -1
self.tables.pop(table_name)
return 0
def callPainter():
str = textBox.get('1.0', "end")
# Parser(string, show=False)
# paint=True函数绘图
Parser(str, paint=True)
def read_line(cls, line):
"""
Parses the string and calls the method from table class
"""
line = Parser.remove_comments(line)
if line:
with Timer() as t:
if ':=' in line:
left, right = Parser.splitlr(line)
if 'inputfromfile' in right:
inp_name = Parser.parse(right, 'input')
output = Table(left, inp_name)
elif 'select' in right:
base_table, args, condition = Parser.parse(
right, 'select')
output = getattr(
cls, base_table).select(
args, condition, left)
elif 'project' in right:
base_table, args = Parser.parse(right, 'project')
output = getattr(cls, base_table).project(args, left)
elif 'avggroup' in right:
base_table, args = Parser.parse(right, 'project')
output = getattr(
cls, base_table).avg_sum_count_group(
args, left)
elif 'movavg' in right:
base_table, args = Parser.parse(right, 'project')
output = getattr(
cls, base_table).moving_avg_sum(
args, left)
setattr(cls, left, output)
elif 'avg' in right:
base_table, args = Parser.parse(right, 'avg')
output = getattr(cls, base_table).avg_sum_count(args)
elif 'sumgroup' in right:
base_table, args = Parser.parse(right, 'project')
output = getattr(
cls, base_table).avg_sum_count_group(
args, left, 'sum')
elif 'movsum' in right:
base_table, args = Parser.parse(right, 'project')
output = getattr(
cls, base_table).moving_avg_sum(
args, left, 'sum')
elif 'sum' in right:
base_table, args = Parser.parse(right, 'avg')
output = getattr(
cls, base_table).avg_sum_count(
args, 'sum')
elif 'sort' in right:
base_table, args = Parser.parse(right, 'project')
output = getattr(cls, base_table).sort(args, left)
elif 'join' in right:
name1, name2, args, condition = Parser.parse(
right, 'join')
table1 = getattr(cls, name1)
table2 = getattr(cls, name2)
output = Table.join(
name1, name2, args, condition, left, table1, table2)
elif 'concat' in right:
args = Parser.parse(right, 'concat')
tables = []
for a in args:
tables.append(getattr(getattr(cls, a), 't'))
output = Table.concat(tables, left)
elif 'countgroup' in right:
base_table, args = Parser.parse(right, 'project')
output = getattr(
cls, base_table).avg_sum_count_group(
args, left, 'count')
elif 'count' in right:
base_table, args = Parser.parse(right, 'avg')
output = getattr(
cls, base_table).avg_sum_count(
args, 'count')
setattr(cls, left, output)
cls.f.write(line + '\n')
cls.f.write(str(output))
cls.f.write('\n')
else:
base_table, col = Parser.parse(line, 'Btree')
table = getattr(cls, base_table)
if line.startswith('Btree'):
table.index_btree(col)
elif line.startswith('Hash'):
table.index_hash(col)
elif line.startswith('outputtofile'):
table.output(col)
print(line, '\nQuery took %.06f sec.\n' % t.interval)
def test_get_place(self):
""" If all is OK, Parser will return the name of the place. """
parser = Parser(self.GOOD_QUESTION)
assert parser.get_place() == self.PLACE
