import copy

import operator

import re

import UserDict

import warnings

import dicts

import exc

import iters

import objects

import strings

import util

##### Names

identifier_max_len = 63 # works for both PostgreSQL and MySQL

def concat(str_, suffix):

    '''Preserves version so that it won't be truncated off the string, leading

    # Preserve version

    match = re.match(r'^(.*?)((?:(?:#\d+)?\)?)*(?:\.\w+)?(?:::[\w ]+)*)$', str_)

    if match:

    return strings.concat(str_, suffix, identifier_max_len)

def truncate(str_): return concat(str_, '')

def is_safe_name(name):

    '''A name is safe *and unambiguous* if it:

    '''

def esc_name(name, quote='"'):

def clean_name(name): return name.replace('"', '').replace('`', '')

def esc_comment(comment): return '/*'+comment.replace('*/', '* /')+'*/'

##### General SQL code objects

class MockDb:

    def esc_value(self, value): return strings.repr_no_u(value)

    def esc_name(self, name): return esc_name(name)

mockDb = MockDb()

class BasicObject(objects.BasicObject):

##### Unparameterized code objects

class Code(BasicObject):

    def to_str(self, db): raise NotImplementedError()

    def __repr__(self): return self.to_str(mockDb)

class CustomCode(Code):

    def __init__(self, str_): self.str_ = str_

def as_Code(value, db=None):

    else: return Literal(value)

class Expr(Code):

##### Names

    def __init__(self, name):

##### Literal values

class Literal(Code):

    def __init__(self, value): self.value = value

def as_Value(value):

def is_null(value): return isinstance(value, Literal) and value.value == None

##### Derived elements

        '''An element which was derived from some other element(s).

        @param srcs See self.set_srcs()

    def set_srcs(self, srcs, overwrite=True):

        '''

        if not overwrite and self.srcs != (): return # already set

        if srcs == src_self: srcs = (self,)

##### Tables

class Table(Derived):

    def __init__(self, name, schema=None, srcs=(), is_temp=False):

        '''

        @param srcs (Table...)|src_self See Derived.set_srcs()

        '''

        Derived.__init__(self, srcs)

        if util.is_str(name): name = truncate(name)

        self.name = name

        self.is_temp = is_temp

        self.index_cols = {}

    def to_str(self, db):

        if self.schema != None: str_ += as_Name(self.schema).to_str(db)+'.'

        return str_

def is_underlying_table(table):

class NoUnderlyingTableException(Exception): pass

def as_Table(table, schema=None):

    if table == None or isinstance(table, Code): return table

    else: return Table(table, schema)

def suffixed_table(table, suffix):

class NamedTable(Table):

        code = as_Table(code)

        if not isinstance(code, (Table, FunctionCall, Expr)): code = Expr(code)

        if cols != None: cols = [to_name_only_col(c).to_Col() for c in cols]

        str_ = self.code.to_str(db)

        if self.cols != None:

        return str_

def remove_table_rename(table):

##### Columns

class Col(Derived):

    def __init__(self, name, table=None, srcs=()):

        '''

        @param srcs (Col...)|src_self See Derived.set_srcs()

        '''

        Derived.__init__(self, srcs)

        if util.is_str(name): name = truncate(name)

        if util.is_str(table): table = Table(table)

        assert table == None or isinstance(table, Table)

    def to_str(self, db, for_str=False):

        str_ = as_Name(self.name).to_str(db)

        if for_str: str_ = clean_name(str_)

        if self.table != None:

            table = self.table.to_Table()

        return str_

    def __str__(self): return self.to_str(mockDb, for_str=True)

    def to_Col(self): return self

def is_table_col(col): return isinstance(col, Col) and col.table != None

def index_col(col):

def is_temp_col(col): return is_table_col(col) and col.table.is_temp

def as_Col(col, table=None, name=None):

    else: return Col(col, table)

def with_table(col, table):

    if isinstance(col, NamedCol): pass # doesn't take a table

        col = copy.copy(col) # don't modify input!

    return col

def with_default_table(col, table):

    col = as_Col(col)

    if col.table == None: col = with_table(col, table)

    return col

def set_cols_table(table, cols):

def to_name_only_col(col, check_table=None):

    if not is_table_col(col): return col

def suffixed_col(col, suffix):

class NamedCol(Col):

    def __init__(self, name, code):

        Col.__init__(self, name)

        code = as_Value(code)

        return self.code.to_str(db)+' AS '+Col.to_str(self, db)

def remove_col_rename(col):

def underlying_col(col):

    if not isinstance(col, Col): raise NoUnderlyingTableException

    return Col(col.name, underlying_table(col.table), col.srcs)

def wrap(wrap_func, value):

class ColDict(dicts.DictProxy):

    '''A dict that automatically makes inserted entries Col objects'''

    def __init__(self, db, keys_table, dict_={}):

        dicts.DictProxy.__init__(self, {})

        keys_table = as_Table(keys_table)

        self.db = db

        self.table = keys_table

        self.update(dict_) # after setting vars because __setitem__() needs them

    def copy(self): return ColDict(self.db, self.table, self.inner.copy())

    def __getitem__(self, key):

    def __setitem__(self, key, value):

        key = self._key(key)

        if value == None: value = self.db.col_info(key).default

        dicts.DictProxy.__setitem__(self, key, as_Col(value, name=key.name))

    def _key(self, key): return as_Col(key, self.table)

##### Functions

Function = Table

as_Function = as_Table

class InternalFunction(CustomCode): pass

class NamedArg(NamedCol):

class FunctionCall(Code):

    def __init__(self, function, *args, **kw_args):

        '''

        @param args [Code|literal-value...] The function's arguments

        '''

        function = as_Function(function)

        def filter_(arg): return remove_col_rename(as_Value(arg))

def wrap_in_func(function, value):

    return wrap(lambda v: FunctionCall(function, v), value)

def unwrap_func_call(func_call, check_name=None):

##### Casts

##### Conditions

class ColValueCond(Code):

def combine_conds(conds, keyword=None):

##### Condition column comparisons

class ValueCond(BasicObject):

    def __init__(self, value):

        value = remove_col_rename(as_Value(value))

    def to_str(self, db, left_value):

        '''

        @param left_value The Code object that the condition is being applied on

        '''

    def __repr__(self): return self.to_str(mockDb, '<left_value>')

        '''

        ValueCond.__init__(self, value)

    def to_str(self, db, left_value):

        left_value = remove_col_rename(as_Col(left_value))

        right_value = self.value

        operator = self.operator

        passthru_null_ref = [False]

        equals = operator.endswith('=') # also includes <=, >=

        # Handle nullable columns

        if not passthru_null_ref[0]: # NULLs compare equal

            try: left_value = ensure_not_null(db, left_value)

            except ensure_not_null_excs: # fall back to alternate method

            else:

                if isinstance(left_value, EnsureNotNull):

        if equals and is_null(right_value): operator = 'IS'

        left = left_value.to_str(db)

        # Create str

        if check_null:

            str_ = '('+str_+' OR ('+left+' IS NULL AND '+right+' IS NULL))'

        return str_

# Tells as_ValueCond() to assume a non-ValueCond is a literal value

            value = with_default_table(value, default_table)

        return CompareCond(value)

    else: return value

##### Joins

join_same = object() # tells Join the left and right columns have the same name

# Tells Join the left and right columns have the same name and are never NULL

filter_out = object() # tells Join to filter out rows that match the join

class Join(BasicObject):

    def __init__(self, table, mapping={}, type_=None):

        '''

            * if left_table_col is join_same: left_table_col = right_table_col

              * Note that right_table_col must be a string

        @param type_ None (for plain join)|str (e.g. 'LEFT')|filter_out

    def to_str(self, db, left_table_):

        def join(entry):

            # Switch order (right_table_col is on the left in the comparison)

            left_table = self.table

            # Parse left side

            left = with_default_table(left, left_table)

            # Parse special values

            left_on_right = Col(left.name, right_table)

            elif right is join_same_not_null:

                right = CompareCond(left_on_right, '~=')

            # Parse right side

            right = as_ValueCond(right, right_table)

        # Create join condition

        joins = self.mapping

        if joins == {}: join_cond = None

            (v is join_same_not_null for v in joins.itervalues())):

            # all cols w/ USING, so can use simpler USING syntax

            cols = map(to_name_only_col, joins.iterkeys())

        else: join_cond = combine_conds(map(join, joins.iteritems()), 'ON')

        if isinstance(self.table, NamedTable): whitespace = '\n'

        # Create join

        str_ = ''

        str_ += 'JOIN'+whitespace+self.table.to_str(db)

        return str_

    def __repr__(self): return self.to_str(mockDb, '<left_table>')

all_cols = CustomCode('*')

default = CustomCode('DEFAULT')

row_count = FunctionCall(InternalFunction('COUNT'), all_cols)

class Coalesce(FunctionCall):

class Nullif(FunctionCall):

# See <http://www.postgresql.org/docs/8.3/static/datatype-numeric.html>

null_sentinels = {

class EnsureNotNull(Coalesce):

    def __init__(self, value, type_):

        Coalesce.__init__(self, as_Col(value),

            Cast(type_, null_sentinels[type_]))