forked from Raiza.dev/EliteBot
1528 lines
47 KiB
Python
1528 lines
47 KiB
Python
# MySQL Connector/Python - MySQL driver written in Python.
|
|
# Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
|
|
|
|
# MySQL Connector/Python is licensed under the terms of the GPLv2
|
|
# <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
|
|
# MySQL Connectors. There are special exceptions to the terms and
|
|
# conditions of the GPLv2 as it is applied to this software, see the
|
|
# FOSS License Exception
|
|
# <http://www.mysql.com/about/legal/licensing/foss-exception.html>.
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
"""Implementation of Statements."""
|
|
|
|
import json
|
|
import re
|
|
|
|
from .errors import ProgrammingError
|
|
from .expr import ExprParser
|
|
from .compat import STRING_TYPES
|
|
from .constants import Algorithms, Securities
|
|
from .dbdoc import DbDoc
|
|
from .protobuf import mysqlx_crud_pb2 as MySQLxCrud
|
|
from .result import SqlResult, Result, ColumnType
|
|
|
|
class Expr(object):
|
|
def __init__(self, expr):
|
|
self.expr = expr
|
|
|
|
|
|
def flexible_params(*values):
|
|
if len(values) == 1 and isinstance(values[0], (list, tuple,)):
|
|
return values[0]
|
|
return values
|
|
|
|
|
|
def is_quoted_identifier(identifier, sql_mode=""):
|
|
"""Check if the given identifier is quoted.
|
|
|
|
Args:
|
|
identifier (string): Identifier to check.
|
|
sql_mode (Optional[string]): SQL mode.
|
|
|
|
Returns:
|
|
`True` if the identifier has backtick quotes, and False otherwise.
|
|
"""
|
|
if "ANSI_QUOTES" in sql_mode:
|
|
return ((identifier[0] == "`" and identifier[-1] == "`") or
|
|
(identifier[0] == '"' and identifier[-1] == '"'))
|
|
else:
|
|
return identifier[0] == "`" and identifier[-1] == "`"
|
|
|
|
|
|
def quote_identifier(identifier, sql_mode=""):
|
|
"""Quote the given identifier with backticks, converting backticks (`) in
|
|
the identifier name with the correct escape sequence (``) unless the
|
|
identifier is quoted (") as in sql_mode set to ANSI_QUOTES.
|
|
|
|
Args:
|
|
identifier (string): Identifier to quote.
|
|
sql_mode (Optional[string]): SQL mode.
|
|
|
|
Returns:
|
|
A string with the identifier quoted with backticks.
|
|
"""
|
|
if is_quoted_identifier(identifier, sql_mode):
|
|
return identifier
|
|
if "ANSI_QUOTES" in sql_mode:
|
|
return '"{0}"'.format(identifier.replace('"', '""'))
|
|
else:
|
|
return "`{0}`".format(identifier.replace("`", "``"))
|
|
|
|
|
|
def quote_multipart_identifier(identifiers, sql_mode=""):
|
|
"""Quote the given multi-part identifier with backticks.
|
|
|
|
Args:
|
|
identifiers (iterable): List of identifiers to quote.
|
|
sql_mode (Optional[string]): SQL mode.
|
|
|
|
Returns:
|
|
A string with the multi-part identifier quoted with backticks.
|
|
"""
|
|
return ".".join([quote_identifier(identifier, sql_mode)
|
|
for identifier in identifiers])
|
|
|
|
|
|
def parse_table_name(default_schema, table_name, sql_mode=""):
|
|
quote = '"' if "ANSI_QUOTES" in sql_mode else "`"
|
|
delimiter = ".{0}".format(quote) if quote in table_name else "."
|
|
temp = table_name.split(delimiter, 1)
|
|
return (default_schema if len(temp) is 1 else temp[0].strip(quote),
|
|
temp[-1].strip(quote),)
|
|
|
|
|
|
class Statement(object):
|
|
"""Provides base functionality for statement objects.
|
|
|
|
Args:
|
|
target (object): The target database object, it can be
|
|
:class:`mysqlx.Collection` or :class:`mysqlx.Table`.
|
|
doc_based (bool): `True` if it is document based.
|
|
"""
|
|
def __init__(self, target, doc_based=True):
|
|
self._target = target
|
|
self._doc_based = doc_based
|
|
self._connection = target._connection if target else None
|
|
|
|
@property
|
|
def target(self):
|
|
"""object: The database object target.
|
|
"""
|
|
return self._target
|
|
|
|
@property
|
|
def schema(self):
|
|
""":class:`mysqlx.Schema`: The Schema object.
|
|
"""
|
|
return self._target.schema
|
|
|
|
def execute(self):
|
|
"""Execute the statement.
|
|
|
|
Raises:
|
|
NotImplementedError: This method must be implemented.
|
|
"""
|
|
raise NotImplementedError
|
|
|
|
|
|
class FilterableStatement(Statement):
|
|
"""A statement to be used with filterable statements.
|
|
|
|
Args:
|
|
target (object): The target database object, it can be
|
|
:class:`mysqlx.Collection` or :class:`mysqlx.Table`.
|
|
doc_based (Optional[bool]): `True` if it is document based
|
|
(default: `True`).
|
|
condition (Optional[str]): Sets the search condition to filter
|
|
documents or records.
|
|
"""
|
|
def __init__(self, target, doc_based=True, condition=None):
|
|
super(FilterableStatement, self).__init__(target=target,
|
|
doc_based=doc_based)
|
|
self._has_projection = False
|
|
self._has_where = False
|
|
self._has_limit = False
|
|
self._has_sort = False
|
|
self._has_group_by = False
|
|
self._has_having = False
|
|
self._has_bindings = False
|
|
self._binding_map = {}
|
|
self._bindings = []
|
|
if condition is not None:
|
|
self.where(condition)
|
|
|
|
def where(self, condition):
|
|
"""Sets the search condition to filter.
|
|
|
|
Args:
|
|
condition (str): Sets the search condition to filter documents or
|
|
records.
|
|
|
|
Returns:
|
|
mysqlx.FilterableStatement: FilterableStatement object.
|
|
"""
|
|
self._has_where = True
|
|
self._where = condition
|
|
expr = ExprParser(condition, not self._doc_based)
|
|
self._where_expr = expr.expr()
|
|
self._binding_map = expr.placeholder_name_to_position
|
|
return self
|
|
|
|
def _projection(self, *fields):
|
|
fields = flexible_params(*fields)
|
|
self._has_projection = True
|
|
self._projection_str = ",".join(fields)
|
|
self._projection_expr = ExprParser(self._projection_str,
|
|
not self._doc_based).parse_table_select_projection()
|
|
return self
|
|
|
|
def limit(self, row_count, offset=0):
|
|
"""Sets the maximum number of records or documents to be returned.
|
|
|
|
Args:
|
|
row_count (int): The maximum number of records or documents.
|
|
offset (Optional[int]) The number of records or documents to skip.
|
|
|
|
Returns:
|
|
mysqlx.FilterableStatement: FilterableStatement object.
|
|
"""
|
|
self._has_limit = True
|
|
self._limit_offset = offset
|
|
self._limit_row_count = row_count
|
|
return self
|
|
|
|
def sort(self, *sort_clauses):
|
|
"""Sets the sorting criteria.
|
|
|
|
Args:
|
|
*sort_clauses: The expression strings defining the sort criteria.
|
|
|
|
Returns:
|
|
mysqlx.FilterableStatement: FilterableStatement object.
|
|
"""
|
|
sort_clauses = flexible_params(*sort_clauses)
|
|
self._has_sort = True
|
|
self._sort_str = ",".join(sort_clauses)
|
|
self._sort_expr = ExprParser(self._sort_str,
|
|
not self._doc_based).parse_order_spec()
|
|
return self
|
|
|
|
def _group_by(self, *fields):
|
|
fields = flexible_params(*fields)
|
|
self._has_group_by = True
|
|
self._grouping_str = ",".join(fields)
|
|
self._grouping = ExprParser(self._grouping_str,
|
|
not self._doc_based).parse_expr_list()
|
|
|
|
def _having(self, condition):
|
|
self._has_having = True
|
|
self._having = ExprParser(condition, not self._doc_based).expr()
|
|
|
|
def bind(self, *args):
|
|
"""Binds a value to a specific placeholder.
|
|
|
|
Args:
|
|
*args: The name of the placeholder and the value to bind.
|
|
A :class:`mysqlx.DbDoc` object or a JSON string
|
|
representation can be used.
|
|
|
|
Returns:
|
|
mysqlx.FilterableStatement: FilterableStatement object.
|
|
|
|
Raises:
|
|
ProgrammingError: If the number of arguments is invalid.
|
|
"""
|
|
self._has_bindings = True
|
|
count = len(args)
|
|
if count == 1:
|
|
self._bind_single(args[0])
|
|
elif count > 2:
|
|
raise ProgrammingError("Invalid number of arguments to bind")
|
|
else:
|
|
self._bindings.append({"name": args[0], "value": args[1]})
|
|
return self
|
|
|
|
def _bind_single(self, object):
|
|
if isinstance(object, DbDoc):
|
|
self.bind(str(object))
|
|
elif isinstance(object, STRING_TYPES):
|
|
dict = json.loads(object)
|
|
for key in dict.keys():
|
|
self.bind(key, dict[key])
|
|
|
|
def execute(self):
|
|
"""Execute the statement.
|
|
|
|
Raises:
|
|
NotImplementedError: This method must be implemented.
|
|
"""
|
|
raise NotImplementedError
|
|
|
|
|
|
class SqlStatement(Statement):
|
|
"""A statement for SQL execution.
|
|
|
|
Args:
|
|
connection (mysqlx.connection.Connection): Connection object.
|
|
sql (string): The sql statement to be executed.
|
|
"""
|
|
def __init__(self, connection, sql):
|
|
super(SqlStatement, self).__init__(target=None, doc_based=False)
|
|
self._connection = connection
|
|
self._sql = sql
|
|
|
|
def execute(self):
|
|
"""Execute the statement.
|
|
|
|
Returns:
|
|
mysqlx.SqlResult: SqlResult object.
|
|
"""
|
|
self._connection.send_sql(self._sql)
|
|
return SqlResult(self._connection)
|
|
|
|
|
|
class AddStatement(Statement):
|
|
"""A statement for document addition on a collection.
|
|
|
|
Args:
|
|
collection (mysqlx.Collection): The Collection object.
|
|
"""
|
|
def __init__(self, collection):
|
|
super(AddStatement, self).__init__(target=collection)
|
|
self._values = []
|
|
self._ids = []
|
|
|
|
def add(self, *values):
|
|
"""Adds a list of documents into a collection.
|
|
|
|
Args:
|
|
*values: The documents to be added into the collection.
|
|
|
|
Returns:
|
|
mysqlx.AddStatement: AddStatement object.
|
|
"""
|
|
for val in flexible_params(*values):
|
|
if isinstance(val, DbDoc):
|
|
self._values.append(val)
|
|
else:
|
|
self._values.append(DbDoc(val))
|
|
return self
|
|
|
|
def execute(self):
|
|
"""Execute the statement.
|
|
|
|
Returns:
|
|
mysqlx.Result: Result object.
|
|
"""
|
|
if len(self._values) == 0:
|
|
return Result()
|
|
|
|
for doc in self._values:
|
|
self._ids.append(doc.ensure_id())
|
|
|
|
return self._connection.send_insert(self)
|
|
|
|
|
|
class UpdateSpec(object):
|
|
def __init__(self, update_type, source, value=None):
|
|
if update_type == MySQLxCrud.UpdateOperation.SET:
|
|
self._table_set(source, value)
|
|
else:
|
|
self.update_type = update_type
|
|
self.source = source
|
|
if len(source) > 0 and source[0] == '$':
|
|
self.source = source[1:]
|
|
self.source = ExprParser(self.source,
|
|
False).document_field().identifier
|
|
self.value = value
|
|
|
|
def _table_set(self, source, value):
|
|
self.update_type = MySQLxCrud.UpdateOperation.SET
|
|
self.source = ExprParser(source, True).parse_table_update_field()
|
|
self.value = value
|
|
|
|
|
|
class ModifyStatement(FilterableStatement):
|
|
"""A statement for document update operations on a Collection.
|
|
|
|
Args:
|
|
collection (mysqlx.Collection): The Collection object.
|
|
condition (Optional[str]): Sets the search condition to identify the
|
|
documents to be updated.
|
|
"""
|
|
def __init__(self, collection, condition=None):
|
|
super(ModifyStatement, self).__init__(target=collection,
|
|
condition=condition)
|
|
self._update_ops = []
|
|
|
|
def set(self, doc_path, value):
|
|
"""Sets or updates attributes on documents in a collection.
|
|
|
|
Args:
|
|
doc_path (string): The document path of the item to be set.
|
|
value (string): The value to be set on the specified attribute.
|
|
|
|
Returns:
|
|
mysqlx.ModifyStatement: ModifyStatement object.
|
|
"""
|
|
self._update_ops.append(
|
|
UpdateSpec(MySQLxCrud.UpdateOperation.ITEM_SET, doc_path, value))
|
|
return self
|
|
|
|
def change(self, doc_path, value):
|
|
"""Add an update to the statement setting the field, if it exists at
|
|
the document path, to the given value.
|
|
|
|
Args:
|
|
doc_path (string): The document path of the item to be set.
|
|
value (object): The value to be set on the specified attribute.
|
|
|
|
Returns:
|
|
mysqlx.ModifyStatement: ModifyStatement object.
|
|
"""
|
|
self._update_ops.append(
|
|
UpdateSpec(MySQLxCrud.UpdateOperation.ITEM_REPLACE, doc_path,
|
|
value))
|
|
return self
|
|
|
|
def unset(self, *doc_paths):
|
|
"""Removes attributes from documents in a collection.
|
|
|
|
Args:
|
|
doc_path (string): The document path of the attribute to be
|
|
removed.
|
|
|
|
Returns:
|
|
mysqlx.ModifyStatement: ModifyStatement object.
|
|
"""
|
|
self._update_ops.extend([
|
|
UpdateSpec(MySQLxCrud.UpdateOperation.ITEM_REMOVE, x)
|
|
for x in flexible_params(*doc_paths)])
|
|
return self
|
|
|
|
def array_insert(self, field, value):
|
|
"""Insert a value into the specified array in documents of a
|
|
collection.
|
|
|
|
Args:
|
|
field (string): A document path that identifies the array attribute
|
|
and position where the value will be inserted.
|
|
value (object): The value to be inserted.
|
|
|
|
Returns:
|
|
mysqlx.ModifyStatement: ModifyStatement object.
|
|
"""
|
|
self._update_ops.append(
|
|
UpdateSpec(MySQLxCrud.UpdateOperation.ARRAY_INSERT, field, value))
|
|
return self
|
|
|
|
def array_append(self, doc_path, value):
|
|
"""Inserts a value into a specific position in an array attribute in
|
|
documents of a collection.
|
|
|
|
Args:
|
|
doc_path (string): A document path that identifies the array
|
|
attribute and position where the value will be
|
|
inserted.
|
|
value (object): The value to be inserted.
|
|
|
|
Returns:
|
|
mysqlx.ModifyStatement: ModifyStatement object.
|
|
"""
|
|
self._update_ops.append(
|
|
UpdateSpec(MySQLxCrud.UpdateOperation.ARRAY_APPEND, doc_path,
|
|
value))
|
|
return self
|
|
|
|
def execute(self):
|
|
"""Execute the statement.
|
|
|
|
Returns:
|
|
mysqlx.Result: Result object.
|
|
"""
|
|
return self._connection.update(self)
|
|
|
|
|
|
class FindStatement(FilterableStatement):
|
|
"""A statement document selection on a Collection.
|
|
|
|
Args:
|
|
collection (mysqlx.Collection): The Collection object.
|
|
condition (Optional[str]): An optional expression to identify the
|
|
documents to be retrieved. If not specified
|
|
all the documents will be included on the
|
|
result unless a limit is set.
|
|
"""
|
|
def __init__(self, collection, condition=None):
|
|
super(FindStatement, self).__init__(collection, True, condition)
|
|
|
|
def fields(self, *fields):
|
|
"""Sets a document field filter.
|
|
|
|
Args:
|
|
*fields: The string expressions identifying the fields to be
|
|
extracted.
|
|
|
|
Returns:
|
|
mysqlx.FindStatement: FindStatement object.
|
|
"""
|
|
return self._projection(*fields)
|
|
|
|
def group_by(self, *fields):
|
|
"""Sets a grouping criteria for the resultset.
|
|
|
|
Args:
|
|
*fields: The string expressions identifying the grouping criteria.
|
|
|
|
Returns:
|
|
mysqlx.FindStatement: FindStatement object.
|
|
"""
|
|
self._group_by(*fields)
|
|
return self
|
|
|
|
def having(self, condition):
|
|
"""Sets a condition for records to be considered in agregate function
|
|
operations.
|
|
|
|
Args:
|
|
condition (string): A condition on the agregate functions used on
|
|
the grouping criteria.
|
|
|
|
Returns:
|
|
mysqlx.FindStatement: FindStatement object.
|
|
"""
|
|
self._having(condition)
|
|
return self
|
|
|
|
def execute(self):
|
|
"""Execute the statement.
|
|
|
|
Returns:
|
|
mysqlx.DocResult: DocResult object.
|
|
"""
|
|
return self._connection.find(self)
|
|
|
|
|
|
class SelectStatement(FilterableStatement):
|
|
"""A statement for record retrieval operations on a Table.
|
|
|
|
Args:
|
|
table (mysqlx.Table): The Table object.
|
|
*fields: The fields to be retrieved.
|
|
"""
|
|
def __init__(self, table, *fields):
|
|
super(SelectStatement, self).__init__(table, False)
|
|
self._projection(*fields)
|
|
|
|
def group_by(self, *fields):
|
|
"""Sets a grouping criteria for the resultset.
|
|
|
|
Args:
|
|
*fields: The fields identifying the grouping criteria.
|
|
|
|
Returns:
|
|
mysqlx.SelectStatement: SelectStatement object.
|
|
"""
|
|
self._group_by(*fields)
|
|
return self
|
|
|
|
def having(self, condition):
|
|
"""Sets a condition for records to be considered in agregate function
|
|
operations.
|
|
|
|
Args:
|
|
condition (str): A condition on the agregate functions used on the
|
|
grouping criteria.
|
|
|
|
Returns:
|
|
mysqlx.SelectStatement: SelectStatement object.
|
|
"""
|
|
self._having(condition)
|
|
return self
|
|
|
|
def execute(self):
|
|
"""Execute the statement.
|
|
|
|
Returns:
|
|
mysqlx.RowResult: RowResult object.
|
|
"""
|
|
return self._connection.find(self)
|
|
|
|
def get_sql(self):
|
|
where = " WHERE {0}".format(self._where) if self._has_where else ""
|
|
group_by = " GROUP BY {0}".format(self._grouping_str) if \
|
|
self._has_group_by else ""
|
|
having = " HAVING {0}".format(self._having) if self._has_having else ""
|
|
order_by = " ORDER BY {0}".format(self._sort_str) if self._has_sort \
|
|
else ""
|
|
limit = " LIMIT {0} OFFSET {1}".format(self._limit_row_count,
|
|
self._limit_offset) if self._has_limit else ""
|
|
|
|
stmt = ("SELECT {select} FROM {schema}.{table}{where}{group}{having}"
|
|
"{order}{limit}".format(
|
|
select=getattr(self, '_projection_str', "*"),
|
|
schema=self.schema.name, table=self.target.name, limit=limit,
|
|
where=where, group=group_by, having=having, order=order_by))
|
|
|
|
return stmt
|
|
|
|
class InsertStatement(Statement):
|
|
"""A statement for insert operations on Table.
|
|
|
|
Args:
|
|
table (mysqlx.Table): The Table object.
|
|
*fields: The fields to be inserted.
|
|
"""
|
|
def __init__(self, table, *fields):
|
|
super(InsertStatement, self).__init__(target=table, doc_based=False)
|
|
self._fields = flexible_params(*fields)
|
|
self._values = []
|
|
|
|
def values(self, *values):
|
|
"""Set the values to be inserted.
|
|
|
|
Args:
|
|
*values: The values of the columns to be inserted.
|
|
|
|
Returns:
|
|
mysqlx.InsertStatement: InsertStatement object.
|
|
"""
|
|
self._values.append(list(flexible_params(*values)))
|
|
return self
|
|
|
|
def execute(self):
|
|
"""Execute the statement.
|
|
|
|
Returns:
|
|
mysqlx.Result: Result object.
|
|
"""
|
|
return self._connection.send_insert(self)
|
|
|
|
|
|
class UpdateStatement(FilterableStatement):
|
|
"""A statement for record update operations on a Table.
|
|
|
|
Args:
|
|
table (mysqlx.Table): The Table object.
|
|
*fields: The fields to be updated.
|
|
"""
|
|
def __init__(self, table, *fields):
|
|
super(UpdateStatement, self).__init__(target=table, doc_based=False)
|
|
self._update_ops = []
|
|
|
|
def set(self, field, value):
|
|
"""Updates the column value on records in a table.
|
|
|
|
Args:
|
|
field (string): The column name to be updated.
|
|
value (object): The value to be set on the specified column.
|
|
|
|
Returns:
|
|
mysqlx.UpdateStatement: UpdateStatement object.
|
|
"""
|
|
self._update_ops.append(
|
|
UpdateSpec(MySQLxCrud.UpdateOperation.SET, field, value))
|
|
return self
|
|
|
|
def execute(self):
|
|
"""Execute the statement.
|
|
|
|
Returns:
|
|
mysqlx.Result: Result object
|
|
"""
|
|
return self._connection.update(self)
|
|
|
|
|
|
class RemoveStatement(FilterableStatement):
|
|
"""A statement for document removal from a collection.
|
|
|
|
Args:
|
|
collection (mysqlx.Collection): The Collection object.
|
|
"""
|
|
def __init__(self, collection):
|
|
super(RemoveStatement, self).__init__(target=collection)
|
|
|
|
def execute(self):
|
|
"""Execute the statement.
|
|
|
|
Returns:
|
|
mysqlx.Result: Result object.
|
|
"""
|
|
return self._connection.delete(self)
|
|
|
|
|
|
class DeleteStatement(FilterableStatement):
|
|
"""A statement that drops a table.
|
|
|
|
Args:
|
|
table (mysqlx.Table): The Table object.
|
|
condition (Optional[str]): The string with the filter expression of
|
|
the rows to be deleted.
|
|
"""
|
|
def __init__(self, table, condition=None):
|
|
super(DeleteStatement, self).__init__(target=table,
|
|
condition=condition,
|
|
doc_based=False)
|
|
|
|
def execute(self):
|
|
"""Execute the statement.
|
|
|
|
Returns:
|
|
mysqlx.Result: Result object.
|
|
"""
|
|
return self._connection.delete(self)
|
|
|
|
|
|
class CreateCollectionIndexStatement(Statement):
|
|
"""A statement that creates an index on a collection.
|
|
|
|
Args:
|
|
collection (mysqlx.Collection): Collection.
|
|
index_name (string): Index name.
|
|
is_unique (bool): `True` if the index is unique.
|
|
"""
|
|
def __init__(self, collection, index_name, is_unique):
|
|
super(CreateCollectionIndexStatement, self).__init__(target=collection)
|
|
self._index_name = index_name
|
|
self._is_unique = is_unique
|
|
self._fields = []
|
|
|
|
def field(self, document_path, column_type, is_required):
|
|
"""Add the field specification to this index creation statement.
|
|
|
|
Args:
|
|
document_path (string): The document path.
|
|
column_type (string): The column type.
|
|
is_required (bool): `True` if the field is required.
|
|
|
|
Returns:
|
|
mysqlx.CreateCollectionIndexStatement: \
|
|
CreateCollectionIndexStatement object.
|
|
"""
|
|
self._fields.append((document_path, column_type, is_required,))
|
|
return self
|
|
|
|
def execute(self):
|
|
"""Execute the statement.
|
|
|
|
Returns:
|
|
mysqlx.Result: Result object.
|
|
"""
|
|
fields = [item for sublist in self._fields for item in sublist]
|
|
return self._connection.execute_nonquery(
|
|
"xplugin", "create_collection_index", True,
|
|
self._target.schema.name, self._target.name, self._index_name,
|
|
self._is_unique, *fields)
|
|
|
|
|
|
class DropCollectionIndexStatement(Statement):
|
|
"""A statement that drops an index on a collection.
|
|
|
|
Args:
|
|
collection (mysqlx.Collection): The Collection object.
|
|
index_name (string): The index name.
|
|
"""
|
|
def __init__(self, collection, index_name):
|
|
super(DropCollectionIndexStatement, self).__init__(target=collection)
|
|
self._index_name = index_name
|
|
|
|
def execute(self):
|
|
"""Execute the statement.
|
|
|
|
Returns:
|
|
mysqlx.Result: Result object.
|
|
"""
|
|
return self._connection.execute_nonquery(
|
|
"xplugin", "drop_collection_index", True,
|
|
self._target.schema.name, self._target.name, self._index_name)
|
|
|
|
|
|
class TableIndex(object):
|
|
UNIQUE_INDEX = 1
|
|
INDEX = 2
|
|
def __init__(self, name, index_type, columns):
|
|
self._name = name
|
|
self._index_type = index_type
|
|
self._columns = columns
|
|
|
|
def get_sql(self):
|
|
stmt = ""
|
|
if self._index_type is TableIndex.UNIQUE_INDEX:
|
|
stmt += "UNIQUE "
|
|
stmt += "INDEX {0} ({1})"
|
|
return stmt.format(self._name, ",".join(self._columns))
|
|
|
|
|
|
class CreateViewStatement(Statement):
|
|
"""A statement for creating views.
|
|
|
|
Args:
|
|
view (mysqlx.View): The View object.
|
|
replace (Optional[bool]): `True` to add replace.
|
|
"""
|
|
def __init__(self, view, replace=False):
|
|
super(CreateViewStatement, self).__init__(target=view, doc_based=False)
|
|
self._view = view
|
|
self._schema = view.schema
|
|
self._name = view.name
|
|
self._replace = replace
|
|
self._columns = []
|
|
self._algorithm = Algorithms.UNDEFINED
|
|
self._security = Securities.DEFINER
|
|
self._definer = None
|
|
self._defined_as = None
|
|
self._check_option = None
|
|
|
|
def columns(self, columns):
|
|
"""Sets the column names.
|
|
|
|
Args:
|
|
columns (list): The list of column names.
|
|
|
|
Returns:
|
|
mysqlx.CreateViewStatement: CreateViewStatement object.
|
|
"""
|
|
self._columns = [quote_identifier(col) for col in columns]
|
|
return self
|
|
|
|
def algorithm(self, algorithm):
|
|
"""Sets the algorithm.
|
|
|
|
Args:
|
|
mysqlx.constants.ALGORITHMS: The algorithm.
|
|
|
|
Returns:
|
|
mysqlx.CreateViewStatement: CreateViewStatement object.
|
|
"""
|
|
self._algorithm = algorithm
|
|
return self
|
|
|
|
def security(self, security):
|
|
"""Sets the SQL security mode.
|
|
|
|
Args:
|
|
mysqlx.constants.SECURITIES: The SQL security mode.
|
|
|
|
Returns:
|
|
mysqlx.CreateViewStatement: CreateViewStatement object.
|
|
"""
|
|
self._security = security
|
|
return self
|
|
|
|
def definer(self, definer):
|
|
"""Sets the definer.
|
|
|
|
Args:
|
|
definer (string): The definer.
|
|
|
|
Returns:
|
|
mysqlx.CreateViewStatement: CreateViewStatement object.
|
|
"""
|
|
self._definer = definer
|
|
return self
|
|
|
|
def defined_as(self, statement):
|
|
"""Sets the SelectStatement statement for describing the view.
|
|
|
|
Args:
|
|
mysqlx.SelectStatement: SelectStatement object.
|
|
|
|
Returns:
|
|
mysqlx.CreateViewStatement: CreateViewStatement object.
|
|
"""
|
|
self._defined_as = statement
|
|
return self
|
|
|
|
def with_check_option(self, check_option):
|
|
"""Sets the check option.
|
|
|
|
Args:
|
|
mysqlx.constants.CHECK_OPTIONS: The check option.
|
|
|
|
Returns:
|
|
mysqlx.CreateViewStatement: CreateViewStatement object.
|
|
"""
|
|
self._check_option = check_option
|
|
return self
|
|
|
|
def execute(self):
|
|
"""Execute the statement to create a view.
|
|
|
|
Returns:
|
|
mysqlx.View: View object.
|
|
"""
|
|
replace = " OR REPLACE" if self._replace else ""
|
|
definer = " DEFINER = {0}".format(self._definer) \
|
|
if self._definer else ""
|
|
columns = " ({0})".format(", ".join(self._columns)) \
|
|
if self._columns else ""
|
|
view_name = quote_multipart_identifier((self._schema.name, self._name))
|
|
check_option = " WITH {0} CHECK OPTION".format(self._check_option) \
|
|
if self._check_option else ""
|
|
sql = ("CREATE{replace} ALGORITHM = {algorithm}{definer} "
|
|
"SQL SECURITY {security} VIEW {view_name}{columns} "
|
|
"AS {defined_as}{check_option}"
|
|
"".format(replace=replace, algorithm=self._algorithm,
|
|
definer=definer, security=self._security,
|
|
view_name=view_name, columns=columns,
|
|
defined_as=self._defined_as,
|
|
check_option=check_option))
|
|
|
|
self._connection.execute_nonquery("sql", sql)
|
|
return self._view
|
|
|
|
|
|
class AlterViewStatement(CreateViewStatement):
|
|
"""A statement for alter views.
|
|
|
|
Args:
|
|
view (mysqlx.View): The View object.
|
|
"""
|
|
def __init__(self, view):
|
|
super(AlterViewStatement, self).__init__(view)
|
|
|
|
def execute(self):
|
|
"""Execute the statement to alter a view.
|
|
|
|
Returns:
|
|
mysqlx.View: View object.
|
|
"""
|
|
definer = " DEFINER = {0}".format(self._definer) \
|
|
if self._definer else ""
|
|
columns = " ({0})".format(", ".join(self._columns)) \
|
|
if self._columns else ""
|
|
view_name = quote_multipart_identifier((self._schema.name, self._name))
|
|
check_option = " WITH {0} CHECK OPTION".format(self._check_option) \
|
|
if self._check_option else ""
|
|
sql = ("ALTER ALGORITHM = {algorithm}{definer} "
|
|
"SQL SECURITY {security} VIEW {view_name}{columns} "
|
|
"AS {defined_as}{check_option}"
|
|
"".format(algorithm=self._algorithm, definer=definer,
|
|
security=self._security, view_name=view_name,
|
|
columns=columns, defined_as=self._defined_as,
|
|
check_option=check_option))
|
|
|
|
self._connection.execute_nonquery("sql", sql)
|
|
return self._view
|
|
|
|
class CreateTableStatement(Statement):
|
|
"""A statement that creates a new table if it doesn't exist already.
|
|
|
|
Args:
|
|
collection (mysqlx.Schema): The Schema object.
|
|
table_name (string): The name for the new table.
|
|
"""
|
|
tbl_frmt = re.compile(r"(from\s+)([`\"].+[`\"]|[^\.]+)(\s|$)", re.IGNORECASE)
|
|
def __init__(self, schema, table_name):
|
|
super(CreateTableStatement, self).__init__(schema)
|
|
self._charset = None
|
|
self._collation = None
|
|
self._comment = None
|
|
self._as = None
|
|
self._like = None
|
|
self._temp = False
|
|
self._columns = []
|
|
self._f_keys = []
|
|
self._indices = []
|
|
self._p_keys = []
|
|
self._u_indices = []
|
|
self._auto_inc = 0
|
|
self._name = table_name
|
|
|
|
self._tbl_repl = r"\1{0}.\2\3".format(self.schema.get_name())
|
|
|
|
@property
|
|
def table_name(self):
|
|
"""string: The fully qualified name of the Table.
|
|
"""
|
|
return quote_multipart_identifier(parse_table_name(
|
|
self.schema.name, self._name))
|
|
|
|
def _get_table_opts(self):
|
|
options = []
|
|
options.append("AUTO_INCREMENT = {inc}")
|
|
if self._charset:
|
|
options.append("DEFAULT CHARACTER SET = {charset}")
|
|
if self._collation:
|
|
options.append("DEFAULT COLLATE = {collation}")
|
|
if self._comment:
|
|
options.append("COMMENT = '{comment}'")
|
|
|
|
table_opts = ",".join(options)
|
|
return table_opts.format(inc=self._auto_inc, charset=self._charset,
|
|
collation=self._collation, comment=self._comment)
|
|
|
|
def _get_create_def(self):
|
|
defs = []
|
|
if self._p_keys:
|
|
defs.append("PRIMARY KEY ({0})".format(",".join(self._p_keys)))
|
|
for col in self._columns:
|
|
defs.append(col.get_sql())
|
|
for key in self._f_keys:
|
|
defs.append(key.get_sql())
|
|
for index in self._indices:
|
|
defs.append(index.get_sql())
|
|
for index in self._u_indices:
|
|
defs.append(index.get_sql())
|
|
|
|
return ",".join(defs)
|
|
|
|
def like(self, table_name):
|
|
"""Create table with the definition of another existing Table.
|
|
|
|
Args:
|
|
table_name (string): Name of the source table.
|
|
|
|
Returns:
|
|
mysqlx.CreateTableStatement: CreateTableStatement object.
|
|
"""
|
|
self._like = quote_multipart_identifier(
|
|
parse_table_name(self.schema.name, table_name))
|
|
return self
|
|
|
|
def as_select(self, select):
|
|
"""Create the Table and fill it with values from a Select Statement.
|
|
|
|
Args:
|
|
select (object): Select Statement. Can be a string or an instance of
|
|
:class`mysqlx.SelectStatement`.
|
|
|
|
Returns:
|
|
mysqlx.CreateTableStatement: CreateTableStatement object.
|
|
"""
|
|
if isinstance(select, STRING_TYPES):
|
|
self._as = CreateTableStatement.tbl_frmt.sub(self._tbl_repl, select)
|
|
elif isinstance(select, SelectStatement):
|
|
self._as = select.get_sql()
|
|
return self
|
|
|
|
def add_column(self, column_def):
|
|
"""Add a Column to the Table.
|
|
|
|
Args:
|
|
column_def (MySQLx.ColumnDef): Column Definition object.
|
|
|
|
Returns:
|
|
mysqlx.CreateTableStatement: CreateTableStatement object.
|
|
"""
|
|
column_def.set_schema(self.schema.get_name())
|
|
self._columns.append(column_def)
|
|
return self
|
|
|
|
def add_primary_key(self, *keys):
|
|
"""Add multiple Primary Keys to the Table.
|
|
|
|
Args:
|
|
*keys: Fields to be used as Primary Keys.
|
|
|
|
Returns:
|
|
mysqlx.CreateTableStatement: CreateTableStatement object.
|
|
"""
|
|
keys = flexible_params(*keys)
|
|
self._p_keys.extend(keys)
|
|
return self
|
|
|
|
def add_index(self, index_name, *cols):
|
|
"""Adds an Index to the Table.
|
|
|
|
Args:
|
|
index_name (string): Name of the Index.
|
|
*cols: Fields to be used as an Index.
|
|
|
|
Returns:
|
|
mysqlx.CreateTableStatement: CreateTableStatement object.
|
|
"""
|
|
self._indices.append(TableIndex(index_name, TableIndex.INDEX,
|
|
flexible_params(*cols)))
|
|
return self
|
|
|
|
def add_unique_index(self, index_name, *cols):
|
|
"""Adds a Unique Index to the Table.
|
|
|
|
Args:
|
|
index_name (string): Name of the Unique Index.
|
|
*cols: Fields to be used as a Unique Index.
|
|
|
|
Returns:
|
|
mysqlx.CreateTableStatement: CreateTableStatement object.
|
|
"""
|
|
self._u_indices.append(TableIndex(index_name, TableIndex.UNIQUE_INDEX,
|
|
flexible_params(*cols)))
|
|
return self
|
|
|
|
def add_foreign_key(self, name, key):
|
|
"""Adds a Foreign Key to the Table.
|
|
|
|
Args:
|
|
key (MySQLx.ForeignKeyDef): The Foreign Key Definition object.
|
|
|
|
Returns:
|
|
mysqlx.CreateTableStatement: CreateTableStatement object.
|
|
"""
|
|
key.set_schema(self.schema.get_name())
|
|
key.set_name(name)
|
|
self._f_keys.append(key)
|
|
return self
|
|
|
|
def set_initial_auto_increment(self, inc):
|
|
"""Set the initial Auto Increment value for the table.
|
|
|
|
Args:
|
|
inc (int): The initial AUTO_INCREMENT value for the table.
|
|
|
|
Returns:
|
|
mysqlx.CreateTableStatement: CreateTableStatement object.
|
|
"""
|
|
self._auto_inc = inc
|
|
return self
|
|
|
|
def set_default_charset(self, charset):
|
|
"""Sets the default Charset type for the Table.
|
|
|
|
Args:
|
|
charset (string): Charset type.
|
|
|
|
Returns:
|
|
mysqlx.CreateTableStatement: CreateTableStatement object.
|
|
"""
|
|
self._charset = charset
|
|
return self
|
|
|
|
def set_default_collation(self, collation):
|
|
"""Sets the default Collation type for the Table.
|
|
|
|
Args:
|
|
collation (string): Collation type.
|
|
|
|
Returns:
|
|
mysqlx.CreateTableStatement: CreateTableStatement object.
|
|
"""
|
|
self._collation = collation
|
|
return self
|
|
|
|
def set_comment(self, comment):
|
|
"""Add a comment to the Table.
|
|
|
|
Args:
|
|
comment (string): Comment to be added to the Table.
|
|
|
|
Returns:
|
|
mysqlx.CreateTableStatement: CreateTableStatement object.
|
|
"""
|
|
self._comment = comment
|
|
return self
|
|
|
|
def temporary(self):
|
|
"""Set the Table to be Temporary.
|
|
|
|
Returns:
|
|
mysqlx.CreateTableStatement: CreateTableStatement object.
|
|
"""
|
|
self._temp = True
|
|
return self
|
|
|
|
def execute(self):
|
|
"""Execute the statement.
|
|
|
|
Returns:
|
|
mysqlx.Table: Table object.
|
|
"""
|
|
create = "CREATE {table_type} {name}".format(name=self.table_name,
|
|
table_type="TEMPORARY TABLE" if self._temp else "TABLE")
|
|
if self._like:
|
|
stmt = "{create} LIKE {query}"
|
|
else:
|
|
stmt = "{create} ({create_def}) {table_opts} {query}"
|
|
|
|
stmt = stmt.format(
|
|
create=create,
|
|
query=self._like or self._as or "",
|
|
create_def=self._get_create_def(),
|
|
table_opts=self._get_table_opts())
|
|
|
|
self._connection.execute_nonquery("sql", stmt, False)
|
|
return self.schema.get_table(self._name)
|
|
|
|
|
|
class ColumnDefBase(object):
|
|
"""A Base class defining the basic parameters required to define a column.
|
|
|
|
Args:
|
|
name (string): Name of the column.
|
|
type (MySQLx.ColumnType): Type of the column.
|
|
size (int): Size of the column.
|
|
"""
|
|
def __init__(self, name, type, size):
|
|
self._default_schema = None
|
|
self._not_null = False
|
|
self._p_key = False
|
|
self._u_index = False
|
|
self._name = name
|
|
self._size = size
|
|
self._comment = ""
|
|
self._type = type
|
|
|
|
def not_null(self):
|
|
"""Disable NULL values for this column.
|
|
|
|
Returns:
|
|
mysqlx.ColumnDefBase: ColumnDefBase object.
|
|
"""
|
|
self._not_null = True
|
|
return self
|
|
|
|
def unique_index(self):
|
|
"""Set current column as a Unique Index.
|
|
|
|
Returns:
|
|
mysqlx.ColumnDefBase: ColumnDefBase object.
|
|
"""
|
|
self._u_index = True
|
|
return self
|
|
|
|
def comment(self, comment):
|
|
"""Add a comment to the column.
|
|
|
|
Args:
|
|
comment (string): Comment to be added to the column.
|
|
|
|
Returns:
|
|
mysqlx.ColumnDefBase: ColumnDefBase object.
|
|
"""
|
|
self._comment = comment
|
|
return self
|
|
|
|
def primary(self):
|
|
"""Sets the Column as a Primary Key.
|
|
|
|
Returns:
|
|
mysqlx.ColumnDefBase: ColumnDefBase object.
|
|
"""
|
|
self._p_key = True
|
|
return self
|
|
|
|
def set_schema(self, schema):
|
|
self._default_schema = schema
|
|
|
|
|
|
class ColumnDef(ColumnDefBase):
|
|
"""Class containing the complete definition of the Column.
|
|
|
|
Args:
|
|
name (string): Name of the column.
|
|
type (MySQL.ColumnType): Type of the column.
|
|
size (int): Size of the column.
|
|
"""
|
|
def __init__(self, name, type, size=None):
|
|
super(ColumnDef, self).__init__(name, type, size)
|
|
self._ref = None
|
|
self._default = None
|
|
self._decimals = None
|
|
self._ref_table = None
|
|
|
|
self._binary = False
|
|
self._auto_inc = False
|
|
self._unsigned = False
|
|
|
|
self._values = []
|
|
self._ref_fields = []
|
|
|
|
self._charset = None
|
|
self._collation = None
|
|
|
|
def _data_type(self):
|
|
type_def = ""
|
|
if self._size and (ColumnType.is_numeric(self._type) or \
|
|
ColumnType.is_char(self._type) or ColumnType.is_binary(self._type)):
|
|
type_def = "({0})".format(self._size)
|
|
elif ColumnType.is_decimals(self._type) and self._size:
|
|
type_def = "({0}, {1})".format(self._size, self._decimals or 0)
|
|
elif ColumnType.is_finite_set(self._type):
|
|
type_def = "({0})".format(",".join(self._values))
|
|
|
|
if self._unsigned:
|
|
type_def = "{0} UNSIGNED".format(type_def)
|
|
if self._binary:
|
|
type_def = "{0} BINARY".format(type_def)
|
|
if self._charset:
|
|
type_def = "{0} CHARACTER SET {1}".format(type_def, self._charset)
|
|
if self._collation:
|
|
type_def = "{0} COLLATE {1}".format(type_def, self._collation)
|
|
|
|
return "{0} {1}".format(ColumnType.to_string(self._type), type_def)
|
|
|
|
def _col_definition(self):
|
|
null = " NOT NULL" if self._not_null else " NULL"
|
|
auto_inc = " AUTO_INCREMENT" if self._auto_inc else ""
|
|
default = " DEFAULT {default}" if self._default else ""
|
|
comment = " COMMENT '{comment}'" if self._comment else ""
|
|
|
|
defn = "{0}{1}{2}{3}{4}".format(self._data_type(), null, default,
|
|
auto_inc, comment)
|
|
|
|
if self._p_key:
|
|
defn = "{0} PRIMARY KEY".format(defn)
|
|
elif self._u_index:
|
|
defn = "{0} UNIQUE KEY".format(defn)
|
|
if self._ref_table and self._ref_fields:
|
|
ref_table = quote_multipart_identifier(parse_table_name(
|
|
self._default_schema, self._ref_table))
|
|
defn = "{0} REFERENCES {1} ({2})".format(defn, ref_table,
|
|
",".join(self._ref_fields))
|
|
|
|
return defn.format(default=self._default, comment=self._comment)
|
|
|
|
def set_default(self, default_val):
|
|
"""Sets the default value of this Column.
|
|
|
|
Args:
|
|
default_val (object): The default value of the Column. Can be a
|
|
string, number or :class`MySQLx.Expr`.
|
|
|
|
Returns:
|
|
mysqlx.ColumnDef: ColumnDef object.
|
|
"""
|
|
if isinstance(default_val, Expr):
|
|
self._default = default_val.expr
|
|
elif default_val is None:
|
|
self._default = "NULL"
|
|
else:
|
|
self._default = repr(default_val)
|
|
|
|
return self
|
|
|
|
def auto_increment(self):
|
|
"""Set the Column to Auto Increment.
|
|
|
|
Returns:
|
|
mysqlx.ColumnDef: ColumnDef object.
|
|
"""
|
|
self._auto_inc = True
|
|
return self
|
|
|
|
def foreign_key(self, name, *refs):
|
|
"""Sets the Column as a Foreign Key.
|
|
|
|
Args:
|
|
name (string): Name of the referenced Table.
|
|
*refs: Fields this Column references.
|
|
|
|
Returns:
|
|
mysqlx.ColumnDef: ColumnDef object.
|
|
"""
|
|
self._ref_fields = flexible_params(*refs)
|
|
self._ref_table = name
|
|
return self
|
|
|
|
def unsigned(self):
|
|
"""Set the Column as unsigned.
|
|
|
|
Returns:
|
|
mysqlx.ColumnDef: ColumnDef object.
|
|
"""
|
|
self._unsigned = True
|
|
return self
|
|
|
|
def decimals(self, size):
|
|
"""Set the size of the decimal Column.
|
|
|
|
Args:
|
|
size (int): Size of the decimal.
|
|
|
|
Returns:
|
|
mysqlx.ColumnDef: ColumnDef object.
|
|
"""
|
|
self._decimals = size
|
|
return self
|
|
|
|
def charset(self, charset):
|
|
"""Set the Charset type of the Column.
|
|
|
|
Args:
|
|
charset (string): Charset type.
|
|
|
|
Returns:
|
|
mysqlx.ColumnDef: ColumnDef object.
|
|
"""
|
|
self._charset = charset
|
|
return self
|
|
|
|
def collation(self, collation):
|
|
"""Set the Collation type of the Column.
|
|
|
|
Args:
|
|
collation (string): Collation type.
|
|
|
|
Returns:
|
|
mysqlx.ColumnDef: ColumnDef object.
|
|
"""
|
|
self._collation = collation
|
|
return self
|
|
|
|
def binary(self):
|
|
"""Set the current column to binary type.
|
|
|
|
Returns:
|
|
mysqlx.ColumnDef: ColumnDef object.
|
|
"""
|
|
self._binary = True
|
|
return self
|
|
|
|
def values(self, *values):
|
|
"""Set the Enum/Set values.
|
|
|
|
Args:
|
|
*values: Values for Enum/Set type Column.
|
|
|
|
Returns:
|
|
mysqlx.ColumnDef: ColumnDef object.
|
|
"""
|
|
self._values = map(repr, flexible_params(*values))
|
|
return self
|
|
|
|
def get_sql(self):
|
|
return "{0} {1}".format(self._name, self._col_definition())
|
|
|
|
|
|
class GeneratedColumnDef(ColumnDef):
|
|
"""Class used to describe a Generated Column.
|
|
|
|
Args:
|
|
name: Name of the column.
|
|
col_type: Type of the column.
|
|
expr: The Expression used to generate the value of this column.
|
|
"""
|
|
def __init__(self, name, col_type, expr):
|
|
super(GeneratedColumnDef, self).__init__(name, col_type)
|
|
assert isinstance(expr, Expr)
|
|
self._stored = False
|
|
self._expr = expr.expr
|
|
|
|
def stored(self):
|
|
"""Set the Generated Column to be stored.
|
|
|
|
Returns:
|
|
mysqlx.GeneratedColumnDef: GeneratedColumnDef object.
|
|
"""
|
|
self._stored = True
|
|
return self
|
|
|
|
def get_sql(self):
|
|
return "{0} GENERATED ALWAYS AS ({1}){2}".format(
|
|
super(GeneratedColumnDef, self).get_sql(),
|
|
self._expr, " STORED" if self._stored else "")
|
|
|
|
|
|
class ForeignKeyDef(object):
|
|
"""Class describing a Foreign Key."""
|
|
NO_ACTION = 1
|
|
RESTRICT = 2
|
|
CASCADE = 3
|
|
SET_NULL = 4
|
|
|
|
def __init__(self):
|
|
self._fields = []
|
|
self._f_fields = []
|
|
self._name = None
|
|
self._f_table = None
|
|
self._default_schema = None
|
|
self._update_action = self._action(ForeignKeyDef.NO_ACTION)
|
|
self._delete_action = self._action(ForeignKeyDef.NO_ACTION)
|
|
|
|
def _action(self, action):
|
|
if action is ForeignKeyDef.RESTRICT:
|
|
return "RESTRICT"
|
|
elif action is ForeignKeyDef.CASCADE:
|
|
return "CASCADE"
|
|
elif action is ForeignKeyDef.SET_NULL:
|
|
return "SET NULL"
|
|
return "NO ACTION"
|
|
|
|
def set_name(self, name):
|
|
self._name = name
|
|
|
|
def set_schema(self, schema):
|
|
self._default_schema = schema
|
|
|
|
def fields(self, *fields):
|
|
"""Add a list of fields in the parent table.
|
|
|
|
Args:
|
|
*fields: Fields in the given table which constitute the Foreign Key.
|
|
|
|
Returns:
|
|
mysqlx.ForeignKeyDef: ForeignKeyDef object.
|
|
"""
|
|
self._fields = flexible_params(*fields)
|
|
return self
|
|
|
|
def refers_to(self, name, *refs):
|
|
"""Add the child table name and the fields.
|
|
|
|
Args:
|
|
name (string): Name of the referenced table.
|
|
*refs: A list fields in the referenced table.
|
|
|
|
Returns:
|
|
mysqlx.ForeignKeyDef: ForeignKeyDef object.
|
|
"""
|
|
self._f_fields = flexible_params(*refs)
|
|
self._f_table = name
|
|
return self
|
|
|
|
def on_update(self, action):
|
|
"""Define the action on updating a Foreign Key.
|
|
|
|
Args:
|
|
action (int): Action to be performed on updating the reference.
|
|
Can be any of the following values:
|
|
1. ForeignKeyDef.NO_ACTION
|
|
2. ForeignKeyDef.RESTRICT
|
|
3. ForeignKeyDef.CASCADE
|
|
4. ForeignKeyDef.SET_NULL
|
|
|
|
Returns:
|
|
mysqlx.ForeignKeyDef: ForeignKeyDef object.
|
|
"""
|
|
|
|
self._update_action = self._action(action)
|
|
return self
|
|
|
|
def on_delete(self, action):
|
|
"""Define the action on deleting a Foreign Key.
|
|
|
|
Args:
|
|
action (int): Action to be performed on updating the reference.
|
|
Can be any of the following values:
|
|
1. ForeignKeyDef.NO_ACTION
|
|
2. ForeignKeyDef.RESTRICT
|
|
3. ForeignKeyDef.CASCADE
|
|
4. ForeignKeyDef.SET_NULL
|
|
|
|
Returns:
|
|
mysqlx.ForeignKeyDef: ForeignKeyDef object.
|
|
"""
|
|
self._delete_action = self._action(action)
|
|
return self
|
|
|
|
def get_sql(self):
|
|
update = "ON UPDATE {0}".format(self._update_action)
|
|
delete = "ON DELETE {0}".format(self._delete_action)
|
|
key = "FOREIGN KEY {0}({1}) REFERENCES {2} ({3})".format(
|
|
self._name, ",".join(self._fields), quote_multipart_identifier(
|
|
parse_table_name(self._default_schema, self._f_table)),
|
|
",".join(self._f_fields))
|
|
return "{0} {1} {2}".format(key, update, delete)
|