X|@s!ddlZddlZddlmZddlmZddlmZddl m Z ddl m Z ddl mZGdd d eZGd d d eZGd d d eeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGd d!d!eZGd"d#d#eZGd$d%d%eZGd&d'd'eZGd(d)d)eZ Gd*d+d+eZ!Gd,d-d-eZ"dS).N) FieldError)utils)fields)Q)six)cached_propertyc@sEeZdZdZdZdZdZdZdZdZ dZ d Z d d d Z d dZ ddZddZddZddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Z d S)5 Combinablezv Provides the ability to combine one or two objects with some connector. For example F('foo') + F('bar'). +-*/^z%%&|NcCsqt|dsKt|tjr<t|dtj}qKt|}n|rat|||St|||S)Nresolve_expression output_field) hasattr isinstancedatetime timedelta DurationValuer DurationFieldValueCombinedExpression)selfother connectorreversednoderJ/home/ubuntu/projects/ifolica/build/django/django/db/models/expressions.py_combine"szCombinable._combinecCs|j||jdS)NF)r!ADD)rrrrr __add__2szCombinable.__add__cCs|j||jdS)NF)r!SUB)rrrrr __sub__5szCombinable.__sub__cCs|j||jdS)NF)r!MUL)rrrrr __mul__8szCombinable.__mul__cCs|j||jdS)NF)r!DIV)rrrrr __truediv__;szCombinable.__truediv__cCst|j||S)N)typer))rrrrr __div__>szCombinable.__div__cCs|j||jdS)NF)r!MOD)rrrrr __mod__AszCombinable.__mod__cCs|j||jdS)NF)r!POW)rrrrr __pow__DszCombinable.__pow__cCstddS)Nz:Use .bitand() and .bitor() for bitwise logical operations.)NotImplementedError)rrrrr __and__GszCombinable.__and__cCs|j||jdS)NF)r!BITAND)rrrrr bitandLszCombinable.bitandcCstddS)Nz:Use .bitand() and .bitor() for bitwise logical operations.)r0)rrrrr __or__OszCombinable.__or__cCs|j||jdS)NF)r!BITOR)rrrrr bitorTszCombinable.bitorcCs|j||jdS)NT)r!r")rrrrr __radd__WszCombinable.__radd__cCs|j||jdS)NT)r!r$)rrrrr __rsub__ZszCombinable.__rsub__cCs|j||jdS)NT)r!r&)rrrrr __rmul__]szCombinable.__rmul__cCs|j||jdS)NT)r!r()rrrrr __rtruediv__`szCombinable.__rtruediv__cCst|j||S)N)r*r:)rrrrr __rdiv__cszCombinable.__rdiv__cCs|j||jdS)NT)r!r,)rrrrr __rmod__fszCombinable.__rmod__cCs|j||jdS)NT)r!r.)rrrrr __rpow__iszCombinable.__rpow__cCstddS)Nz:Use .bitand() and .bitor() for bitwise logical operations.)r0)rrrrr __rand__lszCombinable.__rand__cCstddS)Nz:Use .bitand() and .bitor() for bitwise logical operations.)r0)rrrrr __ror__qszCombinable.__ror__)!__name__ __module__ __qualname____doc__r"r$r&r(r.r,r2r5r!r#r%r'r)r+r-r/r1r3r4r6r7r8r9r:r;r<r=r>r?rrrr r s<                    rc@s~eZdZdZdZdZdddZddZdd Zd d Z d d Z ddZ e ddZ e ddZdddddddZddZeddZe ddZe ddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Z dS)7BaseExpressionz/ Base class for all query expressions. FNcCs|dk r||_ndS)N) _output_field)rrrrr __init__s zBaseExpression.__init__cCs|jg|jj|S)N) convert_valuerget_db_converters)r connectionrrr rHsz BaseExpression.get_db_converterscCsgS)Nr)rrrr get_source_expressionssz%BaseExpression.get_source_expressionscCst|dkstdS)Nr)lenAssertionError)rexprsrrr set_source_expressionssz%BaseExpression.set_source_expressionscGsdd|DS)NcSsOg|]E}t|dr!|n't|tjr?t|n t|qS)r)rrr string_typesFr).0argrrr s z5BaseExpression._parse_expressions..r)r expressionsrrr _parse_expressionss z!BaseExpression._parse_expressionscCstddS)a Responsible for returning a (sql, [params]) tuple to be included in the current query. Different backends can provide their own implementation, by providing an `as_{vendor}` method and patching the Expression: ``` def override_as_sql(self, compiler, connection): # custom logic return super(Expression, self).as_sql(compiler, connection) setattr(Expression, 'as_' + connection.vendor, override_as_sql) ``` Arguments: * compiler: the query compiler responsible for generating the query. Must have a compile method, returning a (sql, [params]) tuple. Calling compiler(value) will return a quoted `value`. * connection: the database connection used for the current query. Returns: (sql, params) Where `sql` is a string containing ordered sql parameters to be replaced with the elements of the list `params`. z"Subclasses must implement as_sql()N)r0)rcompilerrIrrr as_sqlszBaseExpression.as_sqlcCs.x'|jD]}|r |jr dSq WdS)NTF)rJcontains_aggregate)rexprrrr rXsz!BaseExpression.contains_aggregatecCs.x'|jD]}|r |jr dSq WdS)NTF)rJcontains_column_references)rrYrrr rZsz)BaseExpression.contains_column_referencesTcsH|j}|_|jfdd|jD|S)a  Provides the chance to do any preprocessing or validation before being added to the query. Arguments: * query: the backend query implementation * allow_joins: boolean allowing or denying use of joins in this query * reuse: a set of reusable joins for multijoins * summarize: a terminal aggregate clause * for_save: whether this expression about to be used in a save or update Returns: an Expression to be added to the query. cs(g|]}|jqSr)r)rQrY) allow_joinsqueryreuse summarizerr rSs z5BaseExpression.resolve_expression..)copy is_summaryrNrJ)rr\r[r]r^for_savecr)r[r\r]r^r rs   z!BaseExpression.resolve_expressioncCs|S)zQ Hook used by Lookup.get_prep_lookup() to do custom preparation. r)rfieldrrr _prepareszBaseExpression._preparecCs|jS)N)r)rrrr rcszBaseExpression.fieldcCs%|jdkrtdn|jS)z> Returns the output type of this expressions. Nz4Cannot resolve expression type, unknown output_field)_output_field_or_noner)rrrr rszBaseExpression.output_fieldcCs#|jdkr|jn|jS)a Returns the output field of this expression, or None if no output type can be resolved. Note that the 'output_field' property will raise FieldError if no type can be resolved, but this attribute allows for None values. N)rE_resolve_output_field)rrrr res z$BaseExpression._output_field_or_nonecCs|jdkr|j}t|}|dkr?d|_qx]|D]R}|jdkrg||_n|dk rFt|j|j rFtdqFqFWndS)a Attempts to infer the output type of the expression. If the output fields of all source fields match then we can simply infer the same type here. This isn't always correct, but it makes sense most of the time. Consider the difference between `2 + 2` and `2 / 3`. Inferring the type here is a convenience for the common case. The user should supply their own output_field with more complex computations. If a source does not have an `_output_field` then we exclude it from this check. If all sources are `None`, then an error will be thrown higher up the stack in the `output_field` property. Nrz:Expression contains mixed types. You must set output_field)rEget_source_fieldsrKr __class__r)rsourcesZ num_sourcessourcerrr rfs      "z$BaseExpression._resolve_output_fieldcCsq|j}|j}|dkr%|S|dkr;t|S|jdrTt|S|dkrmtj|S|S)z Expressions provide their own converters because users have the option of manually specifying the output_field which may be a different type from the one the database returns. N FloatFieldZ IntegerField DecimalField)rget_internal_typefloatendswithint backend_utilsZtypecast_decimal)rvalue expressionrIcontextrcZ internal_typerrr rGs        zBaseExpression.convert_valuecCs|jj|S)N)r get_lookup)rlookuprrr ru"szBaseExpression.get_lookupcCs|jj|S)N)r get_transform)rnamerrr rw%szBaseExpression.get_transformcs6|j}|jfdd|jD|S)Ncsg|]}|jqSr)relabeled_clone)rQe) change_maprr rS+s z2BaseExpression.relabeled_clone..)r_rNrJ)rr{cloner)r{r ry(s  zBaseExpression.relabeled_clonecCstj|}d|_|S)NT)r_copied)rrbrrr r_.s zBaseExpression.copycCsD|js|gSg}x'|jD]}|j|jq#W|S)N)rXrJextendget_group_by_cols)rcolsrjrrr r3s  z BaseExpression.get_group_by_colscCsdd|jDS)zT Returns the underlying field types used by this aggregate. cSsg|]}|jqSr)re)rQrzrrr rS@s z4BaseExpression.get_source_fields..)rJ)rrrr rg;sz BaseExpression.get_source_fieldscCs t|S)N)OrderBy)rrrr ascBszBaseExpression.asccCst|ddS)N descendingT)r)rrrr descEszBaseExpression.desccCs|S)Nr)rrrr reverse_orderingHszBaseExpression.reverse_orderingccsE|Vx9|jD]+}|rx|jD] }|Vq+WqqWdS)zi Recursively yield this expression and all subexpressions, in depth-first order. N)rJflatten)rrYZ inner_exprrrr rKs zBaseExpression.flatten)!r@rArBrCr`rErFrHrJrNrUrWrrXrZrrdpropertyrcrrerfrGrurwryr_rrgrrrrrrrr rDws8                   rDc@seZdZdZdS) ExpressionzD An expression that can be combined with other expressions. N)r@rArBrCrrrr rWs rcs|eZdZdfddZddZddZdd Zd d Zd d ZdddddddZ S)rNcs8tt|jd|||_||_||_dS)Nr)superrrFrlhsrhs)rrrrr)rhrr rF`s  zCombinedExpression.__init__cCsdj|jj|S)Nz<{}: {}>)formatrhr@)rrrr __repr__fszCombinedExpression.__repr__cCsdj|j|j|jS)Nz{} {} {})rrrr)rrrr __str__iszCombinedExpression.__str__cCs|j|jgS)N)rr)rrrr rJlsz)CombinedExpression.get_source_expressionscCs|\|_|_dS)N)rr)rrMrrr rNosz)CombinedExpression.set_source_expressionsc Csy|jj}Wntk r*d}YnXy|jj}Wntk rUd}YnX|jj r|r{|jdks|r|jdkrt|j|j|jj ||S|r|r|j|j kr|jdkr|j|jkrt |j|jj ||Sg}g}|j |j\}}|j ||j||j |j\}}|j ||j|d} |jj|j|}| ||fS)Nr DateField DateTimeField TimeFieldz(%s)>rrr)rrrrfeatureshas_native_duration_fieldrmDurationExpressionrrWr$TemporalSubtractioncompileappendr~opsZcombine_expression) rrVrIZ lhs_outputZ rhs_outputrTexpression_paramssqlparamsexpression_wrapperrrr rWrs6     %    zCombinedExpression.as_sqlTFcCs[|j}||_|jj||||||_|jj||||||_|S)N)r_r`rrr)rr\r[r]r^rarbrrr rs   !!z%CombinedExpression.resolve_expression) r@rArBrFrrrJrNrWrrr)rhr r^s      rc@s(eZdZddZddZdS)rc Cs~t|tsqy |j}Wntk r0YqqX|jdkrq|j|\}}|jj||fSn|j|S)Nr)rrrrrmrrZformat_for_duration_arithmetic)rZsiderVrIoutputrrrrr rs  zDurationExpression.compilecCs|jj|g}g}|j|j||\}}|j||j||j|j||\}}|j||j|d}|jj|j|}|||fS)Nz(%s)) rcheck_expression_supportrrrr~rZcombine_duration_expressionr)rrVrIrTrrrrrrr rWs    zDurationExpression.as_sqlN)r@rArBrrWrrrr rs  rcs.eZdZfddZddZS)rcs/tt|j||j|dtjdS)Nr)rrrFr$rr)rrr)rhrr rFszTemporalSubtraction.__init__cCs\|jj||j|j|}|j|j|}|jj|jjj||S)N)rrrrrZsubtract_temporalsrrm)rrVrIrrrrr rWszTemporalSubtraction.as_sql)r@rArBrFrWrr)rhr rs rc@saeZdZdZddZddZdddddd d Zd d Zd dZdS)rPzN An object capable of resolving references to existing query objects. cCs ||_dS)z^ Arguments: * name: the name of the field this expression references N)rx)rrxrrr rFsz F.__init__cCsdj|jj|jS)Nz{}({}))rrhr@rx)rrrr rsz F.__repr__NTFcCs|j|j|||S)N)Z resolve_refrx)rr\r[r]r^rarrr rszF.resolve_expressioncCs t|S)N)r)rrrr rszF.asccCst|ddS)NrT)r)rrrr rszF.desc) r@rArBrCrFrrrrrrrr rPs    rPcseZdZdZdZdZdZdZfddZddZ d d Z d d Z dd dddddZ dddddZ ddZfddZS)Funcz An SQL function call. Nz%(function)s(%(expressions)s)z, cs|jdk rgt||jkrgtd|jj|j|jdkrNdndt|fn|jdd}tt|jd||j ||_ ||_ dS)Nz#'%s' takes exactly %s %s (%s given)argument argumentsr) arityrK TypeErrorrhr@poprrrFrUsource_expressionsextra)rrTrr)rhrr rFs$ z Func.__init__cCs||jjdd|jD}djdd|jjD}|rfdj|jj||Sdj|jj|S)Ncss|]}t|VqdS)N)str)rQrRrrr sz Func.__repr__..z, css/|]%\}}t|dt|VqdS)=N)r)rQkeyvalrrr rsz {}({}, {})z{}({})) arg_joinerjoinrritemsrrhr@)rargsrrrr rs "%z Func.__repr__cCs|jS)N)r)rrrr rJszFunc.get_source_expressionscCs ||_dS)N)r)rrMrrr rNszFunc.set_source_expressionsTFc Cs[|j}||_x?t|jD].\}}|j||||||j|)rhr@)rrrr rsz When.__repr__cCs|j|jgS)N)rr)rrrr rJszWhen.get_source_expressionscCs|\|_|_dS)N)rr)rrMrrr rNszWhen.set_source_expressionscCs |jjgS)N)rre)rrrr rgszWhen.get_source_fieldsTFcCsp|j}||_t|jdrK|jj||||d|_n|jj||||||_|S)NrF)r_r`rrrr)rr\r[r]r^rarbrrr rs   $!zWhen.resolve_expressionc Ks|jj||}g}|j|j\}}||d<|j||j|j\} } | |d<|j| |p|j}|||fS)Nrr)rrrrr~rr) rrVrIrrtemplate_params sql_paramsZ condition_sqlZcondition_paramsZ result_sqlZ result_paramsrrr rWs    z When.as_sqlcCs4g}x'|jD]}|j|jqW|S)N)rJr~r)rrrjrrr r szWhen.get_group_by_cols) r@rArBrrFrrrJrNrgrrWrrr)rhr rs       rcseZdZdZdZdZfddZddZdd Zd d Z d d Z dddddddZ fddZ ddddZ S)Casez An SQL searched CASE expression: CASE WHEN n > 0 THEN 'positive' WHEN n < 0 THEN 'negative' ELSE 'zero' END z#CASE %(cases)s ELSE %(default)s END cstdd|Ds(tdn|jdd}|jdd}tt|j|t||_|j|d|_ ||_ dS)Ncss|]}t|tVqdS)N)rr)rQcaserrr r#sz Case.__init__..z.Positional arguments must all be When objects.defaultrr) allrrrrrFlistcasesrUrr)rrrrr)rhrr rF"sz Case.__init__cCs*ddjdd|jD|jfS)NzCASE %s, ELSE %rz, css|]}t|VqdS)N)r)rQrbrrr r-szCase.__str__..)rrr)rrrr r,sz Case.__str__cCsd|jj|fS)Nz<%s: %s>)rhr@)rrrr r/sz Case.__repr__cCs|j|jgS)N)rr)rrrr rJ2szCase.get_source_expressionscCs$|dd|_|d|_dS)Nrr)rr)rrMrrr rN5szCase.set_source_expressionsNTFc Cs||j}||_x?t|jD].\}}|j||||||j|s4  k: R,  !9K