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