def clientthread(conn):
qe = QueryEngine()
#Sending message to connected client
#conn.send('Welcome to the server. Type something and hit enter\n') #send only takes string
#infinite loop so that function do not terminate and thread do not end.
while True:
#Receiving from client
reply = ''
data = conn.recv(1024)
#print data
params = qe.deserialize(data)
param_type = params[0]
print param_type
print 'PARAMS', params
if param_type == QueryType.SELECT:
reply = db.select(msToSec(params[1]), params[2])
elif param_type == QueryType.INSERT:
if params[2]=='':
pass
else:
db.insert(msToSec(params[1]),params[2], params[3])
reply = "inserting " + data
#reply = db.insert(params[1:])
elif param_type == QueryType.UPDATE:
reply = "updating"
#reply = db.update(params[1:])
elif param_type == QueryType.SELECTRANGE:
#dbResponse = list(db.selectRangeForDisplay(msToSec(params[1]), msToSec(params[2]), params[3]))
dbResponse = list(db.selectRangeAndInterval(msToSec(params[1]), msToSec(params[2]), params[3],params[4]))
dbResponse.insert(0, QueryType.SERVER_REPLY)
reply = qe.serialize(dbResponse)
elif param_type == QueryType.INC_AVG:
reply = db.getRunningAverage(params[1]);
elif param_type == QueryType.INC_COUNT:
reply = db.getAggregateCountInRange(msToSec(params[1]), msToSec(params[2]), params[3])
elif param_type == QueryType.INC_VAR:
reply = db.getRunningVariance(params[1]);
else:
# throw exception
reply = "Invalid arguments, should be start with SELECT, INSERT, or UPDATE"
print reply
conn.sendall(reply)
#conn.close()
conn.close()
class TweetListener(StreamListener):
def __init__(self, host, port):
self.sock = socket.socket()
self.sock.connect((host, port))
self.queryEngine = QueryEngine()
def checkWords(self, wordList, text):
for word in wordList:
if word in text:
return True
return False
def on_data(self, data):
#print data
print 'START'
newdata = json.loads(data)
keywords = Constants.KEYWORDS
if "text" in newdata:
text = newdata["text"]
#print 'DATA', data
timestamp = newdata["timestamp_ms"]
keywordMap = {}
text = text.replace("'", "")
# print 'TEXT', text
for word in keywords:
#print "word", word
#print 'text', text
wordList = keywords[word]
if self.checkWords(wordList,text):
if not word in keywordMap:
keywordMap[word]=1
else:
keywordMap[word]+=1
# print "keyword map", keywordMap
currMax = 0
maxKeyWord = ''
for word in keywordMap.keys():
if keywordMap[word] > currMax:
currMax = keywordMap[word]
maxKeyWord = word
print keywordMap
queryString = self.queryEngine.serialize([QueryType.INSERT, timestamp, maxKeyWord, 1])
print queryString
self.sock.send(queryString)
# df1= json.loads(data)
# print "df1", df1
# df = DataFrame(df1)
#print "df", df
# df.to_excel('twitter-excel.xlsx', sheet_name='sheet1', index=False)
return True
def on_error(self, status):
print status
def close(self):
self.sock.close()
from QueryEngine import QueryEngine
from Minibaza import Baza, Kolekcija
QE = QueryEngine()
query = "(def osobe (bp 'test'))(def dok {'ime' 'Pero' 'prihod' 5000})(def dok2 {'ime' 'Ivo' 'prihod' 2000})(?+ osobe 'kolekcija' dok)(?+ osobe 'kolekcija' dok2)(za-svaki d (?> osobe 'kolekcija' {'prihod' 7000})(print d))(ako (> 1 2) 'rrr' (za-svaki d (?> osobe 'kolekcija' {'prihod' 1000})(print d)))"
QE.newQuery(query)
from QueryEngine import QueryEngine
from flask import flash
qe = QueryEngine()
qe.setup_default()
def login_check(username, password):
qe.connect()
check_acc = qe.do_query("select count(*) from log_in where UserName = '******' and Password_hash = md5('" +
password + "')")
count = check_acc[0][0]
qe.disconnect()
if count == 1:
#print("I am in")
return True
else:
#print("wrong account")
return False
def account_type(username, password):
login_id = get_login(username, password)
qe.connect()
patient_type = qe.do_query(
"select count(*) from patient where Patient_ID = " + str(login_id))
doctor_type = qe.do_query(
"select count(*) from doctor where Doctor_ID = " + str(login_id))
staff_type = qe.do_query("select count(*) from staff where Staff_ID = " +
str(login_id))
def __init__(self, host, port):
self.sock = socket.socket()
self.sock.connect((host, port))
self.queryEngine = QueryEngine()
def main(batchfile, dryrun=False, log=False):
def _parse_query(sql, parameterfile):
with open(parameterfile) as pf:
paramdict = json.load(pf)
parsed_sql = sql.format(**paramdict)
return parsed_sql
def _parse_batchfile(batchfile):
with open(batchfile, 'r') as bf:
batchdict = json.load(bf)
defaultsetting = batchdict["DefaultSetting"]
executes = batchdict["Execute"]
return defaultsetting, executes
def _get_targetdbinfo(dbinfofile, dbinfo):
with open(dbinfofile, "r") as di:
dbs = yaml.safe_load(di)
dbdict = dbs[dbinfo]
return dbdict
def _get_query_from_file(sqlfile):
with open(sqlfile, 'r') as sqlf:
query = sqlf.read()
return query
def _overwritesetting(defaultsetting, execute):
defalultkeys = defaultsetting.keys()
for dkey in defalultkeys:
if dkey not in execute.keys():
execute[dkey] = defaultsetting[dkey]
return execute
if log:
if not os.path.exists(logpath):
os.makedirs(logpath)
now = datetime.datetime.now().strftime('%Y%m%d%H%M%S')
logname = logpath + 'qe_' + now + '.log'
loggerfh = logging.FileHandler(logname)
loggerfh.setLevel(logging.INFO)
loggerfh.setFormatter(logging.Formatter(formatter))
logger.addHandler(loggerfh)
logger.info('Logfile Name : %s', logname)
logger.info('LOGGINIG : %s', log)
logger.info('BATCH FILE : %s', batchfile)
logger.info('DRYRUNMODE : %s', dryrun)
defautsetting, executes = _parse_batchfile(batchfile)
for step, execute in executes.items():
logger.info('QUERYSTEP : %i', int(step))
setting = _overwritesetting(defautsetting, execute)
dbinfofile = setting["DatabaseInfoFile"]
engine = setting["QueryEngine"]
dbinfo = setting["DatabaseInfo"]
sqlfile = setting["SQLFile"]
logger.info('DBinfofile : %s', dbinfofile)
logger.info('Engine : %s', engine)
logger.info('DBInfo : %s', dbinfo)
logger.info('SQLFile : %s', sqlfile)
parameter = setting["Parameter"] if "Parameter" in setting.keys(
) else None
option = setting["Option"] if "Option" in setting.keys() else None
logger.info('ParameterFile : %s', parameter)
logger.info('Option : %s', option)
targetdbdict = _get_targetdbinfo(dbinfofile, dbinfo)
qe = QueryEngine(engine, targetdbdict)
query = _get_query_from_file(sqlfile)
if parameter != None:
query = _parse_query(query, parameter)
logger.info('Execute Query')
logger.info('\n' + query)
# Skip connection & execute if dryrun mode.
if dryrun:
continue
try:
qe.connect()
except Exception as e:
logger.error(e)
break
try:
result = qe.execute(query)
except Exception as e:
logger.error(e)
break
logger.info('RESULT : %s', result)
logger.info("END")
