def init_jdbc(): ############################ # Purpose: open a JDBC connection to # this Actor's pgSQL dbase # Caller: main ############################# module = "utils: init_jdbc" # print "in ", module d, u, p, v = "jdbc:postgresql://localhost/rsnadb", "edge", "edge01", "org.postgresql.Driver" # d,u,p,v = "jdbc:postgresql://172.22.3.85/rsnadb","edge","edge01","org.postgresql.Driver" try: # if called from command line with .login CLASSPATH setup right, this works db = zxJDBC.connect(d, u, p, v) except: # if called from Apache or account where the .login has not set CLASSPATH # need to use run-time classPathHacker try: jarLoad = classPathHacker() a = jarLoad.addFile("postgresql.jar") db = zxJDBC.connect(d, u, p, v) except: sys.exit("still failed \n%s" % (db)) sys.exit("still failed \n%s" % (sys.exc_info())) return db
def addPlant(args): if len(args) != 3: usage() name = args[0] descrip = args[1] rating = args[2] con = zxJDBC.connect(*CONNECT_ARGS) cur = con.cursor() cur.execute("select * from Plant_DB where p_name = '%s'" % name) row = cur.fetchone() if row: #if cur.rowcount == 1: sql = "update Plant_DB set p_desc='%s', p_rating='%s' where p_name='%s'" % \ (descrip, rating, name) print 'sql:', sql cur.execute(sql) con.commit() print 'Updated' else: cur.execute("insert into Plant_DB values ('%s', '%s', '%s')" % (name, descrip, rating)) con.commit() print 'Added' showPlants1(cur) cur.close() con.close()
def __init__(self, args): username = args[Constant.WH_DB_USERNAME_KEY] password = args[Constant.WH_DB_PASSWORD_KEY] jdbc_driver = args[Constant.WH_DB_DRIVER_KEY] jdbc_url = args[Constant.WH_DB_URL_KEY] conn_mysql = zxJDBC.connect(jdbc_url, username, password, jdbc_driver) cur = conn_mysql.cursor() try: query = "select distinct f.flow_id, f.flow_name, f.flow_group, ca.app_code from flow f join cfg_application ca on f.app_id = ca.app_id order by app_code, flow_name" cur.execute(query) flows = cur.fetchall() self.flow_dict = dict() for flow in flows: current = self.flow_dict # if needed, use flow[3].replace(' ', '.') current = current.setdefault(flow[3], {}) if flow[2] is not None: current = current.setdefault(flow[2], {}) # for oozie else: current = current.setdefault('NA', {}) current = current.setdefault(flow[1], {}) current["__ID_OF_FLOW__"] = flow[0] self.file_name = args[Constant.FLOW_TREE_FILE_NAME_KEY] self.value = [] finally: cur.close() conn_mysql.close()
def _cursor( self, connection, kwargs ): if not connection: self.connectionFactory = kwargs.get( 'options' ) and kwargs.get( 'options' ).get( 'CONNECTION_FACTORY' ) or None if self.connectionFactory: con = self.connectionFactory.getConnection() connection = PyConnection( con ) else: host = kwargs.get( 'host' ) or 'localhost' port = kwargs.get( 'port' ) and ( ':%s' % kwargs.get( 'port' )) or '' if not ( host.lower() == 'localhost' ): conn_string = "jdbc:db2://%s%s/%s" % ( host, port, kwargs.get( 'database' ) ) else: conn_string = "jdbc:db2:%s" % ( kwargs.get( 'database' ) ) # for Setting default AUTO COMMIT off on connection. autocommit = False if kwargs.get( 'options' ) and kwargs.get( 'options' ).keys().__contains__( 'autocommit' ): autocommit = kwargs.get( 'options' ).get( 'autocommit' ) del kwargs.get( 'options' )['autocommit'] connection = zxJDBC.connect( conn_string, kwargs.get( 'user' ), kwargs.get( 'password' ), 'com.ibm.db2.jcc.DB2Driver', kwargs.get( 'options' ) ) # To prevent dirty reads self.__prevent_dirty_reads( connection ) connection.__connection__.setAutoCommit( autocommit ) return connection, DB2CursorWrapper( connection.cursor() ) else: return DB2CursorWrapper( connection.cursor() )
def test(user, pwd): conn = zxJDBC.connect("jdbc:mysql://localhost/flycircuit", user, pwd, "org.gjt.mm.mysql.Driver") # For local testing cursor = conn.cursor() cursor.execute("SELECT * FROM flycircuit_driver_map") dc = dict_cursor(cursor) for d in dc: print d.items()
def get_new_connection(self, kwargs): self.connectionFactory = kwargs.get( 'options' ) and kwargs.get( 'options' ).get( 'CONNECTION_FACTORY' ) or None if self.connectionFactory: con = self.connectionFactory.getConnection() connection = PyConnection( con ) else: host = kwargs.get( 'host' ) or 'localhost' port = kwargs.get( 'port' ) and ( ':%s' % kwargs.get( 'port' )) or '' DriverType = 4 kwargsKeys = kwargs.keys() if kwargsKeys.__contains__( 'DriverType' ): DriverType = kwargs['DriverType'] if DriverType == 4: conn_string = "jdbc:db2://%s%s/%s" % ( host, port, kwargs.get( 'database' ) ) elif DriverType == 2: conn_string = "jdbc:db2:%s" % ( kwargs.get( 'database' ) ) else: raise ImproperlyConfigured( "Wrong Driver type" ) # for Setting default AUTO COMMIT off on connection. autocommit = False if kwargs.get( 'options' ) and kwargs.get( 'options' ).keys().__contains__( 'autocommit' ): autocommit = kwargs.get( 'options' ).get( 'autocommit' ) del kwargs.get( 'options' )['autocommit'] connection = zxJDBC.connect( conn_string, kwargs.get( 'user' ), kwargs.get( 'password' ), 'com.ibm.db2.jcc.DB2Driver', kwargs.get( 'options' ) ) # To prevent dirty reads self.__prevent_dirty_reads( connection ) connection.__connection__.setAutoCommit( autocommit ) return connection
def _cursor_from_settings_dict(self, settings_dict): cursor = None if self.connection is None: # Configure and connect to database using zxJDBC if settings_dict['NAME'] == '': from django.core.exceptions import ImproperlyConfigured raise ImproperlyConfigured("You need to specify NAME in your Django settings file.") host = settings_dict['HOST'] or 'localhost' port = (settings_dict['PORT'] and (':%s' % settings_dict['PORT']) or '') conn_string = "jdbc:oracle:thin:@%s%s:%s" % (host, port, settings_dict['NAME']) self.connection = Database.connect( conn_string, settings_dict['USER'], settings_dict['PASSWORD'], "oracle.jdbc.OracleDriver", **settings_dict['OPTIONS']) # make transactions transparent to all cursors cursor = CursorWrapper(self.connection.cursor()) # Set oracle date to ansi date format. This only needs to execute # once when we create a new connection. cursor.execute("ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD' " "NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF'") try: self.connection.stmtcachesize = 20 except: pass if not cursor: cursor = CursorWrapper(self.connection.cursor()) return cursor
def GetConnector(): if (ConnectorPool.cursor == 0): ConnectorPool.connection = zxJDBC.connect( "jdbc:mysql://localhost/Project", "root", "1234", "org.gjt.mm.mysql.Driver") ConnectorPool.cursor = ConnectorPool.connection.cursor() return ConnectorPool.cursor
def readDatabase(self, station): import datetime self.clearBoard() dow = datetime.datetime.now().strftime("%a") connectionUrl = "jdbc:mysql://192.168.0.12:3306" with zxJDBC.connect(connectionUrl, "foggyhollow", "foggyhollow", "com.mysql.jdbc.Driver") as conn: query = "select * from foggyhollow.station_schedules where station=? and arlv='Lv' and (trainDays like ? or trainDays like 'Daily') order by str_to_date(scheduleTime, '%l:%i %p') ;" with conn: with conn.cursor() as c: c.execute(query, [station, "%" + dow + "%"]) try: i = 1 row = c.fetchone() while row != None and i < 11: memories.getMemory("Train Number:" + str(i)).setValue(str(row[1])) memories.getMemory("Direction:" + str(i)).setValue( str(row[5])) memories.getMemory("Train Name:" + str(i)).setValue(str(row[2])) memories.getMemory("Time:" + str(i)).setValue( str(row[4])) memories.getMemory("Destination:" + str(i)).setValue(str(row[7])) row = c.fetchone() i = i + 1 except StopIteration: print ""
def change_pass(uuid, pw): conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver") curs = conn.cursor() curs.execute("UPDATE secret SET pass = ? WHERE uuid = ?", (pw,uuid,)) conn.commit() curs.close() conn.close()
def run(userid, terreinid, landscapename): #Connect to postgres conn = zxJDBC.connect(jdbc_url,username, password, driver) cur = conn.cursor() query = """ INSERT INTO administration.runs ("user", model, status, percentage, lastupdate) VALUES (?,?,?, ?, now()); """ data = [1,4,"scheduled",0] cur.execute(query, data) conn.commit() query = """SELECT MAX(id) FROM administration.runs;""" cur.execute(query) result = cur.fetchone() runid = result[0] query = """ INSERT INTO administration.params_makelcp (run, terrein_id, terrein_name) VALUES (?, ?, ?); """ data = [runid,terreinid,landscapename] cur.execute(query, data ) conn.commit() import subprocess p = subprocess.Popen(['/usr/bin/curl','-u', 'demo:demo','http://model.geodan.nl/main/gmi/cgi-bin/makeLcp.py']) p.daemon = True return '{"runid":'+str(runid)+',"status":"scheduled","percentage":0}'
def getCodeFolder(id): # try: ret = None d,u,p,v = "jdbc:mysql://localhost/cmd_main",'root',"","org.gjt.mm.mysql.Driver" with zxJDBCA.connect(d,u,p,v,CHARSET='utf-8') as conn: with conn: with conn.cursor() as c: c.datahandler = PyHandler(c.datahandler) pId = id; if pId is None: pId = '' str = "select * from codefolder where parentid = '" + pId + "'" print 'get folder sql string ',str # str = "select * from codefolder " # print str c.execute(str) # print json.dumps(c.fetchall()).decode('unicode-escape') # print c.rowcount # while (c.next()): all = c.fetchall() print 'get all folder:....',all # print json.dumps(all).decode('unicode-escape') return json.dumps(all).decode('unicode-escape')
def init(context): global db db = zxJDBC.connect("jdbc:h2:" + context.storageFolder.getPath() + "/quotedb/db", "sa", "", "org.h2.Driver") execute("create table if not exists quotes (quotegroup text, " "quotenumber int, quotetext text, hidden boolean)") execute("create table if not exists quoteinfo (quotegroup text, " "quotenumber int,key text, value text)") execute("create table if not exists quotesequence (quotegroup text, " "nextquote int)") Configuration.register(None, "quote", "This folder holds configuration " "variables related to the quote plugin.", VarType.folder, None) Configuration.register(None, "quote/groupnames", "A space-separated list " "of groups that quotes can be added to.", VarType.text, "") Configuration.register(None, "quote/port", "The port to listen for HTTP " "requests on. If this is unset, the HTTP server " "will not be started. This only takes effect " "at restart.", VarType.integer, None) if Configuration.isSet(None, "quote/port"): server = HTTPServer(("", Configuration.getInt(None, "quote/port")), HTTPHandler) class ServerThread(Thread): def run(self): server.serve_forever() ServerThread().start()
def createInstans(i): cnxn = zxJDBC.connect(jdbc_url, username, password, driver_class) crsr = cnxn.cursor() for iInsert in range(50): gender = random.randrange(2) mark = random.randrange(2) if gender == 1: # мужик или не мужик вот в чем вопрос ¯\_(ツ)_/¯ firstName = getRandNameMan() familyName = getRandFamilyName() otch = getRandOtchMan() else: firstName = getRandNameFemale() familyName = getRandFamilyName() + 'a' otch = getRandOtchWomen() fio = firstName + " " + familyName + " " + otch execIns = "INSERT INTO " + nameTable + str( i + 1) + " (ID, FIO, nameSup, DT, mark) VALUES (" + str( iInsert + 1) + ", '" + fio + "', '" + getRandSubject( ) + "', '" + getRandDate() + "', " + str(mark) + ")" listLog.append(execIns.encode("utf-8")) print( str(iInsert + 1) + ")Создан запрос запросом: ", execIns.encode("utf-8")) crsr.execute(execIns) crsr.close() cnxn.commit() cnxn.close()
def db_connect(self, init=False): if init or (datetime.now() - self.connect_time).total_seconds() > self.connection_interval: if self.conn_hms: self.conn_hms.close() self.conn_hms = zxJDBC.connect(self.jdbc_url, self.username, self.password, self.jdbc_driver) self.logger.info("Connected to Hive metadata-store DB") self.connect_time = datetime.now()
def __init__(self, args): self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__) self.app_id = int(args[Constant.APP_ID_KEY]) self.wh_exec_id = long(args[Constant.WH_EXEC_ID_KEY]) self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY], args[Constant.WH_DB_USERNAME_KEY], args[Constant.WH_DB_PASSWORD_KEY], args[Constant.WH_DB_DRIVER_KEY]) self.wh_cursor = self.wh_con.cursor() self.aw_con = self.get_connection(args[Constant.AW_DB_URL_KEY], args[Constant.AW_DB_PORT_KEY], args[Constant.AW_DB_NAME_KEY], args[Constant.AW_DB_USERNAME_KEY], args[Constant.AW_DB_PASSWORD_KEY], args[Constant.AW_DB_DRIVER_KEY]) self.aw_cursor = self.aw_con.cursor() self.lookback_period = args[Constant.AW_EXEC_ETL_LOOKBACK_KEY] self.app_folder = args[Constant.WH_APP_FOLDER_KEY] self.metadata_folder = self.app_folder + "/" + str( SchedulerType.APPWORX) + "/" + str(self.app_id) self.last_execution_unix_time = None self.get_last_execution_unix_time() if not os.path.exists(self.metadata_folder): try: os.makedirs(self.metadata_folder) except Exception as e: self.logger.error(e)
def __init__(self, args): SchedulerTransform.__init__(self, args, SchedulerType.LHOTSE) self.wh_con_1 = zxJDBC.connect(args[Constant.WH_DB_URL_KEY], args[Constant.WH_DB_USERNAME_KEY], args[Constant.WH_DB_PASSWORD_KEY], args[Constant.WH_DB_DRIVER_KEY]) self.wh_cursor_1 = self.wh_con_1.cursor()
def __init__(self, args): self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__) username = args[Constant.WH_DB_USERNAME_KEY] password = args[Constant.WH_DB_PASSWORD_KEY] JDBC_DRIVER = args[Constant.WH_DB_DRIVER_KEY] JDBC_URL = args[Constant.WH_DB_URL_KEY] self.input_table_file = args[Constant.ORA_SCHEMA_OUTPUT_KEY] self.input_field_file = args[Constant.ORA_FIELD_OUTPUT_KEY] self.input_sample_file = args[Constant.ORA_SAMPLE_OUTPUT_KEY] self.db_id = args[Constant.DB_ID_KEY] self.wh_etl_exec_id = args[Constant.WH_EXEC_ID_KEY] self.conn_mysql = zxJDBC.connect(JDBC_URL, username, password, JDBC_DRIVER) self.conn_cursor = self.conn_mysql.cursor() if Constant.INNODB_LOCK_WAIT_TIMEOUT in args: lock_wait_time = args[Constant.INNODB_LOCK_WAIT_TIMEOUT] self.conn_cursor.execute("SET innodb_lock_wait_timeout = %s;" % lock_wait_time) self.logger.info( "Load Oracle Metadata into {}, db_id {}, wh_exec_id {}".format( JDBC_URL, self.db_id, self.wh_etl_exec_id))
def delete_pass(uuid): conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver") curs = conn.cursor() curs.execute("DELETE FROM secret WHERE uuid = ?", (uuid,)) conn.commit() curs.close() conn.close()
def init_db_conn(connect_string, username, passwd): """initializes db connections""" global _CONN if not _CONN: global _CONNECT_STRING global _USERNAME global _PASSWD _CONNECT_STRING = connect_string _USERNAME = username _PASSWD = passwd dbinfo = connect_string try: if USE_JYTHON: print(dbinfo) _CONN = zxJDBC.connect(connect_string, username, passwd, 'com.informix.jdbc.IfxDriver') else: (dbname, dbuser, _) = connect_string.split('/', 3) dbinfo = 'db: %s:%s' % (dbname, dbuser) try: _CONN = odbc.odbc(connect_string) print(dbinfo) except KeyboardInterrupt: raise except: ex = sys.exc_info() s = 'Exception: %s: %s\n%s' % (ex[0], ex[1], dbinfo) print(s) return None return _CONN
def test(): d, u, p, v = ( "jdbc:postgresql://thrush:5432/test", # ... host, port, database "postgres", # user name "Flicker", # pass word "org.postgresql.Driver", # driver ) db = zxJDBC.connect(d, u, p, v, CHARSET='iso_1') cur = db.cursor() cur.execute('select * from plant_db') rows = cur.fetchall() s1 = '%s %s %s' % ( 'Name'.ljust(12), 'Description'.ljust(24), 'Rating'.ljust(10), ) print s1 s1 = '%s %s %s' % ( '===='.ljust(12), '==========='.ljust(24), '======'.ljust(10), ) print s1 for row in rows: rating = str(row[2]) print '%s %s %s' % ( row[0].ljust(12), row[1].ljust(24), rating.ljust(10), ) cur.close() db.close()
def __init__(self, args): self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__) self.app_id = int(args[Constant.JOB_REF_ID_KEY]) self.wh_exec_id = long(args[Constant.WH_EXEC_ID_KEY]) self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY], args[Constant.WH_DB_USERNAME_KEY], args[Constant.WH_DB_PASSWORD_KEY], args[Constant.WH_DB_DRIVER_KEY]) self.wh_cursor = self.wh_con.cursor() self.aw_con = self.get_connection(args[Constant.AW_DB_URL_KEY], args[Constant.AW_DB_PORT_KEY], args[Constant.AW_DB_NAME_KEY], args[Constant.AW_DB_USERNAME_KEY], args[Constant.AW_DB_PASSWORD_KEY], args[Constant.AW_DB_DRIVER_KEY]) self.aw_cursor = self.aw_con.cursor() self.lookback_period = args[Constant.AW_EXEC_ETL_LOOKBACK_KEY] self.app_folder = args[Constant.WH_APP_FOLDER_KEY] self.metadata_folder = self.app_folder + "/" + str(SchedulerType.APPWORX) + "/" + str(self.app_id) self.last_execution_unix_time = None self.get_last_execution_unix_time() if not os.path.exists(self.metadata_folder): try: os.makedirs(self.metadata_folder) except Exception as e: self.logger.error(e)
def __init__(self, args): self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__) username = args[Constant.WH_DB_USERNAME_KEY] password = args[Constant.WH_DB_PASSWORD_KEY] JDBC_DRIVER = args[Constant.WH_DB_DRIVER_KEY] JDBC_URL = args[Constant.WH_DB_URL_KEY] self.input_table_file = args[Constant.ORA_SCHEMA_OUTPUT_KEY] self.input_field_file = args[Constant.ORA_FIELD_OUTPUT_KEY] self.input_sample_file = args[Constant.ORA_SAMPLE_OUTPUT_KEY] self.db_id = args[Constant.DB_ID_KEY] self.wh_etl_exec_id = args[Constant.WH_EXEC_ID_KEY] self.conn_mysql = zxJDBC.connect(JDBC_URL, username, password, JDBC_DRIVER) self.conn_cursor = self.conn_mysql.cursor() if Constant.INNODB_LOCK_WAIT_TIMEOUT in args: lock_wait_time = args[Constant.INNODB_LOCK_WAIT_TIMEOUT] self.conn_cursor.execute("SET innodb_lock_wait_timeout = %s;" % lock_wait_time) self.logger.info("Load Oracle Metadata into {}, db_id {}, wh_exec_id {}" .format(JDBC_URL, self.db_id, self.wh_etl_exec_id)) self.dict_dataset_table = 'dict_dataset' self.field_comments_table = 'field_comments' self.dict_field_table = 'dict_field_detail' self.dict_field_comment_table = 'dict_dataset_field_comment' self.dict_dataset_sample_table = 'dict_dataset_sample'
def __init__(self, args): self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__) username = args[Constant.WH_DB_USERNAME_KEY] password = args[Constant.WH_DB_PASSWORD_KEY] JDBC_DRIVER = args[Constant.WH_DB_DRIVER_KEY] JDBC_URL = args[Constant.WH_DB_URL_KEY] self.db_id = args[Constant.JOB_REF_ID_KEY] self.wh_etl_exec_id = args[Constant.WH_EXEC_ID_KEY] self.conn_mysql = zxJDBC.connect(JDBC_URL, username, password, JDBC_DRIVER) self.conn_cursor = self.conn_mysql.cursor() if Constant.INNODB_LOCK_WAIT_TIMEOUT in args: lock_wait_time = args[Constant.INNODB_LOCK_WAIT_TIMEOUT] self.conn_cursor.execute("SET innodb_lock_wait_timeout = %s;" % lock_wait_time) temp_dir = FileUtil.etl_temp_dir(args, "ORACLE") self.input_table_file = os.path.join(temp_dir, args[Constant.ORA_SCHEMA_OUTPUT_KEY]) self.input_field_file = os.path.join(temp_dir, args[Constant.ORA_FIELD_OUTPUT_KEY]) self.input_sample_file = os.path.join(temp_dir, args[Constant.ORA_SAMPLE_OUTPUT_KEY]) self.collect_sample = False if Constant.ORA_LOAD_SAMPLE in args: self.collect_sample = FileUtil.parse_bool(args[Constant.ORA_LOAD_SAMPLE], False) self.logger.info("Load Oracle Metadata into {}, db_id {}, wh_exec_id {}" .format(JDBC_URL, self.db_id, self.wh_etl_exec_id))
def run(userid,geom, name, fuelmodel, weatherstring, windstring, startmonth, startday, starthour, stoplines): #Connect to postgres conn = zxJDBC.connect(jdbc_url,username, password, driver) cur = conn.cursor() query = """ INSERT INTO administration.runs ("user", model, status, percentage, lastupdate) VALUES (?,?,?,?, now()); """ data = [1,5,"scheduled",0] cur.execute(query, data) conn.commit() query = """SELECT MAX(id) FROM administration.runs;""" cur.execute(query) result = cur.fetchone() runid = result[0] cur = conn.cursor() query = """ INSERT INTO administration.params_farsiterun (run, name, fuelmodel, point, weatherstring, windstring, startmonth, startday, starthour, stoplines) VALUES (?,?,?,?,?,?,?,?,?,?); """ data = [runid,name,fuelmodel,geom,weatherstring,windstring,startmonth,startday,starthour, stoplines] cur.execute(query, data ) conn.commit() runid_out = runid modelname = 'farsiteRun' status_out = "scheduled" percentage_out = 0 import subprocess p = subprocess.Popen(['/usr/bin/curl','-u','demo:demo', 'http://model.geodan.nl/main/gmi/cgi-bin/farsiteRun2.py']) return '{"runid":%i,"status":"%s", "percentage":%i}' % (runid_out,status_out, percentage_out)
def __init__(self, args): self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__) username = args[Constant.WH_DB_USERNAME_KEY] password = args[Constant.WH_DB_PASSWORD_KEY] JDBC_DRIVER = args[Constant.WH_DB_DRIVER_KEY] JDBC_URL = args[Constant.WH_DB_URL_KEY] self.db_id = args[Constant.JOB_REF_ID_KEY] self.wh_etl_exec_id = args[Constant.WH_EXEC_ID_KEY] self.conn_mysql = zxJDBC.connect(JDBC_URL, username, password, JDBC_DRIVER) self.conn_cursor = self.conn_mysql.cursor() if Constant.INNODB_LOCK_WAIT_TIMEOUT in args: lock_wait_time = args[Constant.INNODB_LOCK_WAIT_TIMEOUT] self.conn_cursor.execute("SET innodb_lock_wait_timeout = %s;" % lock_wait_time) temp_dir = FileUtil.etl_temp_dir(args, "REDSHIFT") self.input_table_file = os.path.join( temp_dir, args[Constant.RED_SCHEMA_OUTPUT_KEY]) self.input_field_file = os.path.join( temp_dir, args[Constant.RED_FIELD_OUTPUT_KEY]) self.logger.info( "Load Redshift Metadata into {}, db_id {}, wh_exec_id {}".format( JDBC_URL, self.db_id, self.wh_etl_exec_id))
def _cursor(self, settings): set_tz = False if self.connection is None: set_tz = True if settings.DATABASE_NAME == '': from django.core.exceptions import ImproperlyConfigured raise ImproperlyConfigured("You need to specify DATABASE_NAME in your Django settings file.") host = settings.DATABASE_HOST or 'localhost' port = settings.DATABASE_PORT and (':' + settings.DATABASE_PORT) or '' conn_string = "jdbc:postgresql://%s%s/%s" % (host, port, settings.DATABASE_NAME) self.connection = Database.connect(conn_string, settings.DATABASE_USER, settings.DATABASE_PASSWORD, 'org.postgresql.Driver', **self.options) # make transactions transparent to all cursors from java.sql import Connection jdbc_conn = self.connection.__connection__ jdbc_conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED) real_cursor = self.connection.cursor() # setup the JDBC3 DataHandler and our data handler real_cursor.datahandler = JDBC30DataHandler(DjangoDataHandler(real_cursor.datahandler)) cursor = CursorWrapper(real_cursor) if set_tz: # XXX: settings.TIME_ZONE could inject SQL # Does it matter? If someone can edit settings.py, it already # have the user and password! cursor.execute("SET TIME ZONE %s" % self.ops.quote_name(settings.TIME_ZONE)) return cursor
def __init__(self, args): self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__) username = args[Constant.WH_DB_USERNAME_KEY] password = args[Constant.WH_DB_PASSWORD_KEY] JDBC_DRIVER = args[Constant.WH_DB_DRIVER_KEY] JDBC_URL = args[Constant.WH_DB_URL_KEY] self.mp_gitli_project_file = args[Constant.GIT_PROJECT_OUTPUT_KEY] self.product_repo_file = args[Constant.PRODUCT_REPO_OUTPUT_KEY] self.product_repo_owner_file = args[ Constant.PRODUCT_REPO_OWNER_OUTPUT_KEY] self.app_id = args[Constant.APP_ID_KEY] self.wh_etl_exec_id = args[Constant.WH_EXEC_ID_KEY] self.conn_mysql = zxJDBC.connect(JDBC_URL, username, password, JDBC_DRIVER) self.conn_cursor = self.conn_mysql.cursor() if Constant.INNODB_LOCK_WAIT_TIMEOUT in args: lock_wait_time = args[Constant.INNODB_LOCK_WAIT_TIMEOUT] self.conn_cursor.execute("SET innodb_lock_wait_timeout = %s;" % lock_wait_time) self.logger.info( "Load Multiproduct Metadata into {}, app_id {}, wh_exec_id {}". format(JDBC_URL, self.app_id, self.wh_etl_exec_id))
def saveDDL(self): try: driver = "oracle.jdbc.driver.OracleDriver" jdbc_url= "jdbc:oracle:thin:@"+self.connectserverip+":"+self.connectserverport+":"+self.connectservicename driver = "cn.x.db.oracle.driver.wrapper.CommonDriver" jdbc_url = "jdbc:oracle:thin:@192.168.192.135:1521:orcl?characterEncoding=utf-8" connection = zxJDBC.connect(jdbc_url, self.connectusername, self.connectpassword, driver) generator.normalizeArguments(connection) cursor = connection.cursor() sql=self.composeSQL() if (self.argObjectInFile==""): sql2=sql%(self.argOwner,"%") cursor.execute(sql2) #cursor.execute(sql, {'Owner':self.argOwner, 'ObjectName':"%"}) self.saveRowset(cursor) else: for object1 in self.objectList: sql2=sql%(self.argOwner,object1) cursor.execute(sql2) #cursor.execute(sql, {'Owner':self.argOwner, 'ObjectName':object1}) self.saveRowset(cursor) except Exception , ex: print ex
def init(self, config): """servlet startup""" self.props = self.read_dspace_config(DSPACE_DIR + '/config/dspace.cfg') self.conn = zxJDBC.connect( self.props.getProperty('db.url'), self.props.getProperty('db.username'), self.props.getProperty('db.password'), self.props.getProperty('db.driver'), ) self.conn.autocommit = True self.cursor = self.conn.cursor() self.client = self.read_orcid_config_db() self.orcid_pattern = re.compile(r"^\d{4}-\d{4}-\d{4}-(\d{3}X|\d{4})$") self.token_pattern = re.compile( r"^[0-f]{8}-[0-f]{4}-[0-f]{4}-[0-f]{4}-[0-f]{12}$") self.available_scopes = [ '/authenticate', '/activities/update', '/person/update', '/read-limited', '/read-public', '/webhook', ] self.available_envs = [ 'sandbox', 'production', ] self.logger = Logger.getLogger("orcid/auth.py") self.logger.info("initialized")
def __init__(self, args): self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__) username = args[Constant.WH_DB_USERNAME_KEY] password = args[Constant.WH_DB_PASSWORD_KEY] JDBC_DRIVER = args[Constant.WH_DB_DRIVER_KEY] JDBC_URL = args[Constant.WH_DB_URL_KEY] self.database_scm_repo_file = args[ Constant.DATABASE_SCM_REPO_OUTPUT_KEY] self.app_id = args[Constant.APP_ID_KEY] self.wh_etl_exec_id = args[Constant.WH_EXEC_ID_KEY] self.conn_mysql = zxJDBC.connect(JDBC_URL, username, password, JDBC_DRIVER) self.conn_cursor = self.conn_mysql.cursor() if Constant.INNODB_LOCK_WAIT_TIMEOUT in args: lock_wait_time = args[Constant.INNODB_LOCK_WAIT_TIMEOUT] self.conn_cursor.execute("SET innodb_lock_wait_timeout = %s;" % lock_wait_time) self.logger.info( "Load Code Search CSV into {}, app_id {}, wh_exec_id {}".format( JDBC_URL, self.app_id, self.wh_etl_exec_id))
def get_pass(uuid): conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver") curs = conn.cursor() curs.execute("SELECT pass FROM secret WHERE uuid = ?", (uuid,)) results = curs.fetchall() curs.close() conn.close() return results[0][0]
def saveConnection(args): if len(args) != 1: usage() fileName = args[0] con = zxJDBC.connect(*CONNECT_ARGS) cur = con.cursor() cur.execute("select * from Plant_DB order by p_name") save(con, fileName)
def create_pass_thread(uuid, pw): pw = crypt.encrypt(pw, rounds=200000, salt_size=16) conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver") curs = conn.cursor() curs.execute("INSERT INTO secret VALUES (?,?)", (uuid,pw,)) conn.commit() curs.close() conn.close()
def delete_pass(uuid): conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver") curs = conn.cursor() curs.execute("DELETE FROM secret WHERE uuid = ?", (uuid, )) conn.commit() curs.close() conn.close()
def execute_query(query, uuid): conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver") curs = conn.cursor() curs.execute(query, (uuid,)) results = curs.fetchall() curs.close() conn.close() return results
def execute_update(update, uuid): conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver") curs = conn.cursor() curs.execute(update, (uuid, )) conn.commit() curs.close() conn.close()
def __init__(self, args): self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__) self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY], args[Constant.WH_DB_USERNAME_KEY], args[Constant.WH_DB_PASSWORD_KEY], args[Constant.WH_DB_DRIVER_KEY]) self.wh_cursor = self.wh_con.cursor() self.app_id = int(args[Constant.APP_ID_KEY])
def __init__(self, args): self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__) self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY], args[Constant.WH_DB_USERNAME_KEY], args[Constant.WH_DB_PASSWORD_KEY], args[Constant.WH_DB_DRIVER_KEY]) self.wh_cursor = self.wh_con.cursor() self.app_id = int(args[Constant.JOB_REF_ID_KEY])
def __init__(self, args): self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__) self.elasticsearch_index_url = args[Constant.WH_ELASTICSEARCH_URL_KEY] self.elasticsearch_port = args[Constant.WH_ELASTICSEARCH_PORT_KEY] self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY], args[Constant.WH_DB_USERNAME_KEY], args[Constant.WH_DB_PASSWORD_KEY], args[Constant.WH_DB_DRIVER_KEY]) self.wh_cursor = self.wh_con.cursor()
def __init__(self, args): self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__) self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY], args[Constant.WH_DB_USERNAME_KEY], args[Constant.WH_DB_PASSWORD_KEY], args[Constant.WH_DB_DRIVER_KEY]) self.wh_cursor = self.wh_con.cursor() self.wh_exec_id = long(args[Constant.WH_EXEC_ID_KEY]) self.app_folder = args[Constant.WH_APP_FOLDER_KEY]
def __init__(self, args): self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__) self.elasticsearch_index_url = args[Constant.WH_ELASTICSEARCH_URL_KEY] self.elasticsearch_port = args[Constant.WH_ELASTICSEARCH_PORT_KEY] self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY], args[Constant.WH_DB_USERNAME_KEY], args[Constant.WH_DB_PASSWORD_KEY], args[Constant.WH_DB_DRIVER_KEY]) self.wh_cursor = self.wh_con.cursor(1)
def db_connect(self, init=False): if init or (datetime.now() - self.connect_time ).total_seconds() > self.connection_interval: if self.conn_hms: self.conn_hms.close() self.conn_hms = zxJDBC.connect(self.jdbc_url, self.username, self.password, self.jdbc_driver) self.logger.info("Connected to Hive metadata-store DB") self.connect_time = datetime.now()
def execute_query(query, uuid): conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver") curs = conn.cursor() curs.execute(query, (uuid, )) results = curs.fetchall() curs.close() conn.close() return results
def get_pass(uuid): conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver") curs = conn.cursor() curs.execute("SELECT pass FROM secret WHERE uuid = ?", (uuid, )) results = curs.fetchall() curs.close() conn.close() return results[0][0]
def getDbConnection(self): driver = "org.gjt.mm.mysql.Driver" jdbc_url = "jdbc:mysql://localhost/sapdb?useUnicode=yes&characterEncoding=utf-8" username = "******" password = "" conn = zxJDBC.connect(jdbc_url, username, password, driver) return conn
def get_website_data(player): conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver") curs = conn.cursor() uuid = str(uid(player)).replace("-", "") curs.execute("SELECT DISTINCT `id`, `email` FROM users WHERE `uuid` = ? LIMIT 1", (uuid,)) results = curs.fetchall() curs.close() conn.close() return ("http://redstoner.com/users/%s" % results[0][0], results[0][1]) if results else (None, None)
def async_query_t(mysql_database,query,query_args,target,target_args,target_kwargs): db_conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver") db_curs = db_conn.cursor() db_curs.execute(query,query_args) db_conn.commit() fetchall = db_curs.fetchall() db_curs.close() db_conn.close() target(fetchall,target_args,target_kwargs)
def __init__(self, args, scheduler_type): self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__) self.app_id = int(args[Constant.APP_ID_KEY]) self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY], args[Constant.WH_DB_USERNAME_KEY], args[Constant.WH_DB_PASSWORD_KEY], args[Constant.WH_DB_DRIVER_KEY]) self.wh_cursor = self.wh_con.cursor() self.app_folder = args[Constant.WH_APP_FOLDER_KEY] self.metadata_folder = self.app_folder + "/" + str(scheduler_type) + "/" + str(self.app_id)
def __init__(self): self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__) username = args[Constant.HIVE_METASTORE_USERNAME] password = args[Constant.HIVE_METASTORE_PASSWORD] jdbc_driver = args[Constant.HIVE_METASTORE_JDBC_DRIVER] jdbc_url = args[Constant.HIVE_METASTORE_JDBC_URL] self.conn_hms = zxJDBC.connect(jdbc_url, username, password, jdbc_driver) self.curs = self.conn_hms.cursor() dependency_instance_file = args[Constant.HIVE_DEPENDENCY_CSV_FILE_KEY] self.instance_writer = FileWriter(dependency_instance_file)
def get_new_connection(self, conn_params): connection = self.get_new_jndi_connection() if not connection: connection = zxJDBC.connect(self.get_jdbc_connection_url(), conn_params['USER'], conn_params['PASSWORD'], self.jdbc_driver_class_name, **conn_params['OPTIONS']) self._set_default_isolation_level(connection) return connection
def change_pass(uuid, pw): conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver") curs = conn.cursor() curs.execute("UPDATE secret SET pass = ? WHERE uuid = ?", ( pw, uuid, )) conn.commit() curs.close() conn.close()
def __init__(self, dsURL, user, password, dsDriver): self.dsURL = dsURL self.user = user self.password = password self.dsDriver = dsDriver try: self.connection = zxJDBC.connect(self.dsURL, self.user, self.password, self.dsDriver) except Exception, e: print e
def createTables(iTable): cnxn = zxJDBC.connect(jdbc_url, username, password, driver_class) crsr = cnxn.cursor() execTab = "CREATE TABLE " + nameTable + str( iTable + 1 ) + " (ID INT NOT NULL PRIMARY KEY, FIO CHAR(200) NOT NULL, nameSup CHAR(200) NOT NULL, DT DATE NOT NULL, mark BIT DEFAULT 0 NOT NULL)" listLog.append(execTab) print(str(iTable + 1) + ")Создана таблица запросом: " + execTab) crsr.execute(execTab) crsr.close() cnxn.commit() cnxn.close()