def test_ssl_connection(self):
config = {}
config.update(self.connect_kwargs)
# Secure by default
session = mysqlx.get_node_session(config)
res = mysqlx.statement.SqlStatement(session._connection,
"SHOW STATUS LIKE 'Mysqlx_ssl_active'").execute().fetch_all()
self.assertEqual("ON", res[0][1])
res = mysqlx.statement.SqlStatement(session._connection,
"SHOW STATUS LIKE 'Mysqlx_ssl_version'").execute().fetch_all()
self.assertTrue("TLS" in res[0][1])
session.close()
config["ssl-key"] = tests.SSL_KEY
self.assertRaises(mysqlx.errors.InterfaceError,
mysqlx.get_node_session, config)
# Connection with ssl parameters
config["ssl-ca"] = tests.SSL_CA
config["ssl-cert"] = tests.SSL_CERT
session = mysqlx.get_node_session(config)
res = session.sql("SHOW STATUS LIKE 'Mysqlx_ssl_active'") \
.execute().fetch_all()
self.assertEqual("ON", res[0][1])
res = session.sql("SHOW STATUS LIKE 'Mysqlx_ssl_version'") \
.execute().fetch_all()
self.assertTrue("TLS" in res[0][1])
session.close()
ssl_ca="{0}{1}".format(config["ssl-ca"][0],
quote_plus(config["ssl-ca"][1:]))
ssl_key="{0}{1}".format(config["ssl-key"][0],
quote_plus(config["ssl-key"][1:]))
ssl_cert="{0}{1}".format(config["ssl-ca"][0],
quote_plus(config["ssl-cert"][1:]))
uri = build_uri(user=config["user"], password=config["password"],
host=config["host"], ssl_ca=ssl_ca,
ssl_cert=ssl_cert, ssl_key=ssl_key)
session = mysqlx.get_node_session(uri)
ssl_ca = "({0})".format(config["ssl-ca"])
ssl_cert = "({0})".format(config["ssl-cert"])
ssl_key = "({0})".format(config["ssl-key"])
uri = build_uri(user=config["user"], password=config["password"],
host=config["host"], ssl_ca=ssl_ca,
ssl_cert=ssl_cert, ssl_key=ssl_key)
session = mysqlx.get_node_session(uri)
def test_ssl_connection(self):
config = {}
config.update(self.connect_kwargs)
# Secure by default
session = mysqlx.get_node_session(config)
res = mysqlx.statement.SqlStatement(session._connection,
"SHOW STATUS LIKE 'Mysqlx_ssl_active'").execute().fetch_all()
self.assertEqual("ON", res[0][1])
res = mysqlx.statement.SqlStatement(session._connection,
"SHOW STATUS LIKE 'Mysqlx_ssl_version'").execute().fetch_all()
self.assertTrue("TLS" in res[0][1])
session.close()
config["ssl-key"] = tests.SSL_KEY
self.assertRaises(mysqlx.errors.InterfaceError,
mysqlx.get_node_session, config)
# Connection with ssl parameters
config["ssl-ca"] = tests.SSL_CA
config["ssl-cert"] = tests.SSL_CERT
session = mysqlx.get_node_session(config)
res = session.sql("SHOW STATUS LIKE 'Mysqlx_ssl_active'") \
.execute().fetch_all()
self.assertEqual("ON", res[0][1])
res = session.sql("SHOW STATUS LIKE 'Mysqlx_ssl_version'") \
.execute().fetch_all()
self.assertTrue("TLS" in res[0][1])
session.close()
uri = ("mysqlx://{0}:{1}@{2}?ssl-ca={3}&ssl-cert={4}&ssl-key={5}"
"".format(config["user"], config["password"], config["host"],
quote(config["ssl-ca"]), quote(config["ssl-cert"]),
quote(config["ssl-key"])))
session = mysqlx.get_node_session(uri)
uri = ("mysqlx://{0}:{1}@{2}?ssl-ca=({3})&ssl-cert=({4})&ssl-key=({5})"
"".format(config["user"], config["password"], config["host"],
config["ssl-ca"], config["ssl-cert"],
config["ssl-key"]))
session = mysqlx.get_node_session(uri)
def setUp(self):
self.connect_kwargs = tests.get_mysqlx_config()
self.schema_name = self.connect_kwargs["schema"]
try:
self.session = mysqlx.get_node_session(self.connect_kwargs)
except mysqlx.Error as err:
self.fail("{0}".format(err))
def setUp(self):
self.connect_kwargs = tests.get_mysqlx_config()
self.schema_name = self.connect_kwargs["schema"]
try:
self.session = mysqlx.get_node_session(self.connect_kwargs)
except mysqlx.Error as err:
self.fail("{0}".format(err))
def test_disabled_x_protocol(self):
node_session = mysqlx.get_node_session(self.connect_kwargs)
res = node_session.sql("SHOW VARIABLES WHERE Variable_name = 'port'") \
.execute().fetch_all()
settings = self.connect_kwargs.copy()
settings["port"] = res[0][1] # Lets use the MySQL classic port
node_session.close()
self.assertRaises(mysqlx.errors.ProgrammingError, mysqlx.get_session,
settings)
def test_disabled_x_protocol(self):
node_session = mysqlx.get_node_session(self.connect_kwargs)
res = node_session.sql("SHOW VARIABLES WHERE Variable_name = 'port'") \
.execute().fetch_all()
settings = self.connect_kwargs.copy()
settings["port"] = res[0][1] # Lets use the MySQL classic port
node_session.close()
self.assertRaises(mysqlx.errors.ProgrammingError, mysqlx.get_session,
settings)
def test_get_default_schema(self):
schema = self.session.get_default_schema()
self.assertTrue(schema, mysqlx.Schema)
self.assertEqual(schema.get_name(), self.connect_kwargs["schema"])
# Test without default schema configured at connect time
settings = self.connect_kwargs.copy()
settings["schema"] = None
session = mysqlx.get_node_session(settings)
self.assertRaises(mysqlx.ProgrammingError, session.get_default_schema)
session.close()
def test_get_default_schema(self):
schema = self.session.get_default_schema()
self.assertTrue(schema, mysqlx.Schema)
self.assertEqual(schema.get_name(), self.connect_kwargs["schema"])
# Test without default schema configured at connect time
settings = self.connect_kwargs.copy()
settings["schema"] = None
session = mysqlx.get_node_session(settings)
self.assertRaises(mysqlx.ProgrammingError, session.get_default_schema)
session.close()
def test_connection_uri(self):
uri = build_uri(user=self.connect_kwargs["user"],
password=self.connect_kwargs["password"],
host=self.connect_kwargs["host"],
port=self.connect_kwargs["port"],
schema=self.connect_kwargs["schema"])
session = mysqlx.get_node_session(uri)
self.assertIsInstance(session, mysqlx.NodeSession)
# Test URI parser function
for uri, res in _URI_TEST_RESULTS:
try:
settings = mysqlx._get_connection_settings(uri)
self.assertEqual(res, settings)
except mysqlx.Error:
self.assertEqual(res, None)
def test_connection_uri(self):
uri = build_uri(user=self.connect_kwargs["user"],
password=self.connect_kwargs["password"],
host=self.connect_kwargs["host"],
port=self.connect_kwargs["port"],
schema=self.connect_kwargs["schema"])
session = mysqlx.get_node_session(uri)
self.assertIsInstance(session, mysqlx.NodeSession)
# Test URI parser function
for uri, res in _URI_TEST_RESULTS:
try:
settings = mysqlx._get_connection_settings(uri)
self.assertEqual(res, settings)
except mysqlx.Error:
self.assertEqual(res, None)
def connect(self):
col_name = self.term + '_tweets'
session = mysqlx.get_session(mysql_auth)
my_db = session.get_schema(SCHEMA_NAME)
# Get (or create, if necessary) the Collection
try:
col = my_db.get_collection(col_name, check_existence=True)
except mysqlx.errors.ProgrammingError:
logging.info("Need to create Collection " + col_name)
col = my_db.create_collection(col_name)
# only a NodeSession can execute SQL
node_session = mysqlx.get_node_session(mysql_auth)
node_session.sql(
'alter table ' + SCHEMA_NAME + '.' + col_name +
' ADD tweet_id bigint unsigned GENERATED ALWAYS AS ( doc->>"$.id" ), ADD UNIQUE INDEX id_uniq(tweet_id);'
).execute()
return col
def ensure_session():
global testSession
global session
if testSession is None:
print "Creating session...\n"
testSession = mysqlx.get_node_session(__uripwd)
# Ensures the user on dev-api exists
try:
testSession.sql("create user mike@'%' identified by 's3cr3t!'").execute()
testSession.sql("grant all on *.* to mike@'%' with grant option").execute()
except:
pass
else:
print "Session exists...\n"
session = testSession
import mysqlx
# Connect to server using a NodeSession
mySession = mysqlx.get_node_session('mike:s3cr3t!@localhost')
# Switch to use schema 'test'
mySession.sql("USE test").execute()
# In a NodeSession context the full SQL language can be used
sql = """CREATE PROCEDURE my_add_one_procedure
(INOUT incr_param INT)
BEGIN
SET incr_param = incr_param + 1;
END
"""
mySession.sql(sql).execute()
mySession.sql("SET @my_var = ?").bind(10).execute()
mySession.sql("CALL my_add_one_procedure(@my_var)").execute()
mySession.sql("DROP PROCEDURE my_add_one_procedure").execute()
# Use an SQL query to get the result
myResult = mySession.sql("SELECT @my_var").execute()
# Gets the row and prints the first column
row = myResult.fetch_one()
print row[0]
mySession.close()
collection.create_index( 'rtwt_idx', False ).field( "$.retweet_count", "INT", False ).execute()
def add_user_table( session ):
xsession = session
user_collection_name = 'users'
tweet_col = xsession.get_schema( SCHEMA_NAME ).get_collection( tweets_collection )
logging.debug( "Pulling all users" )
users = []
try:
users = tweet_col.find().fields('user').group_by('user.id, user, user.created_at').sort( 'user.created_at').execute().fetch_all()
except Exception as e:
print( str( e ) )
logging.debug( str( type( users ) )+ ": " + str( type( users[0] ) ) )
if( PREPEND_TERM ):
user_collection_name = term + '_' + user_collection_name
user_collection = xsession.get_schema( SCHEMA_NAME).create_collection( user_collection_name, reuse = True )
for u in users:
try:
#logging.debug( u.user[u'screen_name'] )
user_collection.add( u.user ).execute()
except Exception as e:
print( str( e ))
ns = mysqlx.get_node_session( mysql_auth)
xs = mysqlx.get_session( mysql_auth )
add_date_column(ns)
add_user_column(ns)
add_retweet_count_index( xs )
add_user_table( xs)
# Assumptions: validate_crud_functions available
# Assumes __uripwd is defined as <user>:<pwd>@<host>:<plugin_port>
import mysqlx
mySession = mysqlx.get_node_session(__uripwd)
ensure_schema_does_not_exist(mySession, 'js_shell_test')
schema = mySession.create_schema('js_shell_test')
# Creates a test collection and inserts data into it
collection = schema.create_collection('collection1')
# --------------------------------------
# Create index, dynamic function testing
# --------------------------------------
#@ CollectionCreateIndex: valid operations after create_index
create_index = collection.create_index('_name')
validate_crud_functions(create_index, ['field'])
#@ CollectionAdd: valid operations after field
create_index.field('name', "TEXT(50)", True)
validate_crud_functions(create_index, ['field', 'execute'])
#@ CollectionAdd: valid operations after execute
result = create_index.execute()
validate_crud_functions(create_index, [])
# -----------------------------------
# Error conditions on chained methods
# -----------------------------------
#@# Error conditions on create_index
import mysqlx
def process_warnings(result):
if result.get_warning_count():
for warning in result.get_warnings():
print 'Type [%s] (Code %s): %s\n' % (warning.level, warning.code, warning.message)
else:
print "No warnings were returned.\n"
# Connect to server
mySession = mysqlx.get_node_session( {
'host': 'localhost', 'port': 33060,
'dbUser': '******', 'dbPassword': '******' } );
# Disables warning generation
mySession.set_fetch_warnings(False)
result = mySession.sql('drop schema if exists unexisting').execute()
process_warnings(result)
# Enables warning generation
mySession.set_fetch_warnings(True)
result = mySession.sql('drop schema if exists unexisting').execute()
process_warnings(result)
#@ mysqlx module: get_session through data and password
data = {'host': __host, 'port': __port, 'schema': __schema, 'dbUser': __user}
mySession = mysqlx.get_session(data, __pwd)
print mySession, '\n'
if mySession.uri == __displayuridb:
print 'Session using right URI\n'
else:
print 'Session using wrong URI\n'
mySession.close()
#@ mysqlx module: get_node_session through URI
mySession = mysqlx.get_node_session(__uripwd)
print mySession, '\n'
if mySession.uri == __displayuri:
print 'Session using right URI\n'
else:
print 'Session using wrong URI\n'
mySession.close()
#@ mysqlx module: get_node_session through URI and password
mySession = mysqlx.get_node_session(__uri, __pwd)
print mySession, '\n'
mySession.start_transaction()
res1 = collection.add({"name": 'john', "age": 15}).execute()
res2 = collection.add({"name": 'carol', "age": 16}).execute()
res3 = collection.add({"name": 'alma', "age": 17}).execute()
mySession.commit()
result = collection.find().execute()
print 'Inserted Documents:', len(result.fetch_all())
# Cleanup
mySession.drop_schema('session_schema')
mySession.drop_schema('quoted schema')
mySession.close()
#@ NodeSession: validating members
nodeSession = mysqlx.get_node_session(__uripwd)
all_members = dir(nodeSession)
# Remove the python built in members
nodeSessionMembers = []
for member in all_members:
if not member.startswith('__'):
nodeSessionMembers.append(member)
validateMember(nodeSessionMembers, 'close')
validateMember(nodeSessionMembers, 'create_schema')
validateMember(nodeSessionMembers, 'get_current_schema')
validateMember(nodeSessionMembers, 'get_default_schema')
validateMember(nodeSessionMembers, 'get_schema')
validateMember(nodeSessionMembers, 'get_schemas')
validateMember(nodeSessionMembers, 'get_uri')
def test_ssl_connection(self):
config = {}
config.update(self.connect_kwargs)
# Secure by default
session = mysqlx.get_node_session(config)
res = mysqlx.statement.SqlStatement(
session._connection,
"SHOW STATUS LIKE 'Mysqlx_ssl_active'").execute().fetch_all()
self.assertEqual("ON", res[0][1])
res = mysqlx.statement.SqlStatement(
session._connection,
"SHOW STATUS LIKE 'Mysqlx_ssl_version'").execute().fetch_all()
self.assertTrue("TLS" in res[0][1])
session.close()
config["ssl-key"] = tests.SSL_KEY
self.assertRaises(mysqlx.errors.InterfaceError,
mysqlx.get_node_session, config)
# Connection with ssl parameters
config["ssl-ca"] = tests.SSL_CA
config["ssl-cert"] = tests.SSL_CERT
session = mysqlx.get_node_session(config)
res = session.sql("SHOW STATUS LIKE 'Mysqlx_ssl_active'") \
.execute().fetch_all()
self.assertEqual("ON", res[0][1])
res = session.sql("SHOW STATUS LIKE 'Mysqlx_ssl_version'") \
.execute().fetch_all()
self.assertTrue("TLS" in res[0][1])
session.close()
ssl_ca = "{0}{1}".format(config["ssl-ca"][0],
quote_plus(config["ssl-ca"][1:]))
ssl_key = "{0}{1}".format(config["ssl-key"][0],
quote_plus(config["ssl-key"][1:]))
ssl_cert = "{0}{1}".format(config["ssl-ca"][0],
quote_plus(config["ssl-cert"][1:]))
uri = build_uri(user=config["user"],
password=config["password"],
host=config["host"],
ssl_ca=ssl_ca,
ssl_cert=ssl_cert,
ssl_key=ssl_key)
session = mysqlx.get_node_session(uri)
ssl_ca = "({0})".format(config["ssl-ca"])
ssl_cert = "({0})".format(config["ssl-cert"])
ssl_key = "({0})".format(config["ssl-key"])
uri = build_uri(user=config["user"],
password=config["password"],
host=config["host"],
ssl_ca=ssl_ca,
ssl_cert=ssl_cert,
ssl_key=ssl_key)
session = mysqlx.get_node_session(uri)
def createTestTable(session, name):
# use escape function to quote names/identifier
quoted_name = session.quote_name(name)
session.sql("DROP TABLE IF EXISTS " + quoted_name).execute()
create = "CREATE TABLE "
create += quoted_name
create += " (id INT NOT NULL PRIMARY KEY AUTO_INCREMENT)"
session.sql(create).execute()
return session.get_current_schema().get_table(name)
import mysqlx
session = mysqlx.get_node_session({
'dataSourceFile': 'mysqlxconfig.json', 'app': 'myapp',
'dbUser': '******', 'dbPassword': '******'})
default_schema = session.get_default_schema().name
session.set_current_schema(default_schema)
# Creates some tables
table1 = createTestTable(session, 'test1')
table2 = createTestTable(session, 'test2')
