#$@%#$%!

Ngiler SH3LL 360
: / opt / hc_python / lib64 / python3.12 / site-packages / mysqlx /

Information Server
MySQL : OFF Perl : OFF CURL : ON WGET : OFF PKEXEC : OFF

Directive	Local Value
IP Address	162.0.209.101
System	Linux premium169.web-hosting.com 4.18.0-553.50.1.lve.el8.x86_64 #1 SMP Thu Apr 17 19:10:24 UTC 2025 x86_64
User	luxeelil
PHP Version	8.0.30
Software	LiteSpeed
Doc root	Writable

Edit File : statement.py \| Size : 47.08 KB
# 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) Back

Edit File : statement.py | Size : 47.08 KB

# 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.

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)

Back