Current File : //opt/hc_python/lib64/python3.8/site-packages/mysqlx/statement.py
# 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)
Mini Shell