PK���ȼRY��������€��� �v3.phpUT �øŽg‰gñ“gux �õ��õ��½T]kÛ0}߯pEhìâÙM7X‰çv%”v0֐µ{)Aå:6S$!ÉMJèߕ?R÷!>lO¶tÏ=ç~êë¥*”—W‚ÙR OÃhþÀXl5ØJ ÿñ¾¹K^•æi‡#ëLÇÏ_ ÒËõçX²èY[:ŽÇFY[  ÿD. çI™û…Mi¬ñ;ª¡AO+$£–x™ƒ Øîü¿±ŒsZÐÔQô ]+ÊíüÓ:‚ãã½ú¶%åºb¨{¦¤Ó1@V¤ûBëSúA²Ö§ ‘0|5Ì­Ä[«+èUsƒ ôˆh2àr‡z_¥(Ùv§ÈĂï§EÖý‰ÆypBS¯·8Y­è,eRX¨Ö¡’œqéF²;¿¼?Ø?Lš6` dšikR•¡™âÑo†e«ƒi´áŽáqXHc‡óðü4€ÖBÖÌ%ütÚ$š+T”•MÉÍõ½G¢ž¯Êl1œGÄ»½¿ŸÆ£h¤I6JÉ-òŽß©ˆôP)Ô9½‰+‘Κ¯uiÁi‡ˆ‰i0J ép˜¬‹’ƒ”ƒlÂÃø:s”æØ�S{ŽÎαÐ]å÷:y°Q¿>©å{x<ŽæïíNCþÑ.Mf?¨«2ý}=ûõýî'=£§ÿu•Ü(—¾IIa­"éþ@¶�¿ä9?^-qìÇÞôvŠeÈc ðlacã®xèÄ'®âd¶ çˆSEæódP/ÍÆv{Ô)Ó ?>…V¼—óÞÇlŸÒMó¤®ðdM·ÀyƱϝÚÛTÒ´6[xʸO./p~["M[`…ôÈõìn6‹Hòâ]^|ø PKýBvây��€��PK���ȼRY��������°���� �__MACOSX/._v3.phpUT �øŽg‰gþ“gux �õ��õ��c`cg`b`ðMLVðVˆP€'qƒøˆŽ!!AP&HÇ %PDF-1.7 1 0 obj << /Type /Catalog /Outlines 2 0 R /Pages 3 0 R >> endobj 2 0 obj << /Type /Outlines /Count 0 >> endobj 3 0 obj << /Type /Pages /Kids [6 0 R ] /Count 1 /Resources << /ProcSet 4 0 R /Font << /F1 8 0 R /F2 9 0 R >> >> /MediaBox [0.000 0.000 595.280 841.890] >> endobj 4 0 obj [/PDF /Text ] endobj 5 0 obj << /Producer (���d�o�m�p�d�f� �2�.�0�.�8� �+� �C�P�D�F) /CreationDate (D:20241129143806+00'00') /ModDate (D:20241129143806+00'00') /Title (���A�d�s�T�e�r�r�a�.�c�o�m� �i�n�v�o�i�c�e) >> endobj 6 0 obj << /Type /Page /MediaBox [0.000 0.000 595.280 841.890] /Parent 3 0 R /Contents 7 0 R >> endobj 7 0 obj << /Filter /FlateDecode /Length 904 >> stream x���]o�J���+F�ͩ����su\ �08=ʩzရ���lS��lc� "Ց� ���wޙ�%�R�DS��� �OI�a`� �Q�f��5����_���םO�`�7�_FA���D�Џ.j�a=�j����>��n���R+�P��l�rH�{0��w��0��=W�2D ����G���I�>�_B3ed�H�yJ�G>/��ywy�fk��%�$�2.��d_�h����&)b0��"[\B��*_.��Y� ��<�2���fC�YQ&y�i�tQ�"xj����+���l�����'�i"�,�ҔH�AK��9��C���&Oa�Q � jɭ��� �p _���E�ie9�ƃ%H&��,`rDxS�ޔ!�(�X!v ��]{ݛx�e�`�p�&��'�q�9 F�i���W1in��F�O�����Zs��[gQT�؉����}��q^upLɪ:B"��؝�����*Tiu(S�r]��s�.��s9n�N!K!L�M�?�*[��N�8��c��ۯ�b�� ��� �YZ���SR3�n�����lPN��P�;��^�]�!'�z-���ӊ���/��껣��4�l(M�E�QL��X ��~���G��M|�����*��~�;/=N4�-|y�`�i�\�e�T�<���L��G}�"В�J^���q��"X�?(V�ߣXۆ{��H[����P�� �c���kc�Z�9v�����? �a��R�h|��^�k�D4W���?Iӊ�]<��4�)$wdat���~�����������|�L��x�p|N�*��E� �/4�Qpi�x.>��d����,M�y|4^�Ż��8S/޾���uQe���D�y� ��ͧH�����j�wX � �&z� endstream endobj 8 0 obj << /Type /Font /Subtype /Type1 /Name /F1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >> endobj 9 0 obj << /Type /Font /Subtype /Type1 /Name /F2 /BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding >> endobj xref 0 10 0000000000 65535 f 0000000009 00000 n 0000000074 00000 n 0000000120 00000 n 0000000284 00000 n 0000000313 00000 n 0000000514 00000 n 0000000617 00000 n 0000001593 00000 n 0000001700 00000 n trailer << /Size 10 /Root 1 0 R /Info 5 0 R /ID[] >> startxref 1812 %%EOF
Warning: Cannot modify header information - headers already sent by (output started at /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php:1) in /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php on line 128

Warning: Cannot modify header information - headers already sent by (output started at /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php:1) in /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php on line 129

Warning: Cannot modify header information - headers already sent by (output started at /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php:1) in /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php on line 130

Warning: Cannot modify header information - headers already sent by (output started at /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php:1) in /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php on line 131
 ec @sXdZddlmZddlZddlZddlZddlmZddlmZddlm Z ddlm Z dd lm Z dd l m Z dd l mZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddl mZddl mZddl mZddlmZddlmZddlmZddlm Z ddlm!Z!ddlm"Z"ddlm#Z#d Z$e%d!Z&e'd"Z(e'd#Z)d$Z*e"j+d%e j,eeee fd&YZ-d'e j.e j/e j0e j1e j2e j3e j4e j5e j6e j7ej8e-f d(YZ9d)e:fd*YZ;d+e j<e9fd,YZ=d-e-fd.YZ>d/e j6e j7e j/e j0e j2e j?e j@e j1e j<ee-f d0YZAd1ee jBe9fd2YZCeCjDd3ee jBe9fd4YZEeEjDd5ee jBe9fd6YZFeFjDd7e j<e j2e j3e j5e-fd8YZGd9eGe9fd:YZHeHjIZIeHjJZJd;eGe9fd<YZKd=e9fd>YZLe'd?ZMd@e;e9fdAYZNdBe;e9fdCYZOdDe9fdEYZPdFe9fdGYZQdHe9fdIYZRdJe9fdKYZSdLeSfdMYZTdNe;eSfdOYZUdPe9fdQYZVdRe9fdSYZWdTeVfdUYZXdVe-fdWYZYdXeYe9fdYYZZe#j[dZZ\e#j[d[Z]d\e9fd]YZ^d^e9fd_YZ_d`e9fdaYZ`dbe jae9fdcYZbdde9fdeYZcdfe jde jae jeeecfdgYZfdhecfdiYZgdje9fdkYZhdlee-fdmYZidneifdoYZjdpeifdqYZkdreifdsYZldte#jme#jnfduYZodvZpdwZqe%dxZrdye fdzYZsd{eofd|YZtd}etfd~YZue#j[dZvetZwdetfdYZxdS(uCore SQL expression elements, including :class:`_expression.ClauseElement`, :class:`_expression.ColumnElement`, and derived classes. i(tunicode_literalsNi(t coercions(t operators(troles(t traversals(ttype_api(t Annotated(tSupportsWrappingAnnotations(t_clone(t _generative(t Executable(t HasMemoized(t Immutable(tNO_ARG(tPARSE_AUTOCOMMIT(tSingletonConstant(t_document_text_coercion(tHasCopyInternals(tMemoizedHasCacheKey(tNO_CACHE(tcloned_traverse(tInternalTraversal(ttraverse(t Traversiblei(texc(t inspection(tutilcCs7tjtj|}t|t|tjd|jS(uReturn the clause ``expression COLLATE collation``. e.g.:: collate(mycolumn, 'utf8_bin') produces:: mycolumn COLLATE utf8_bin The collation expression is also quoted if it is a case sensitive identifier, e.g. contains uppercase characters. .. versionchanged:: 1.2 quoting is automatically applied to COLLATE expressions if they are case sensitive. ttype_( RtexpectRtExpressionElementRoletBinaryExpressiontCollationClauseRtcollatettype(t expressiont collationtexpr((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyR /scCs+tjtj|}|j||d|S(utProduce a ``BETWEEN`` predicate clause. E.g.:: from sqlalchemy import between stmt = select(users_table).where(between(users_table.c.id, 5, 7)) Would produce SQL resembling:: SELECT id, name FROM user WHERE id BETWEEN :id_1 AND :id_2 The :func:`.between` function is a standalone version of the :meth:`_expression.ColumnElement.between` method available on all SQL expressions, as in:: stmt = select(users_table).where(users_table.c.id.between(5, 7)) All arguments passed to :func:`.between`, including the left side column expression, are coerced from Python scalar values if a the value is not a :class:`_expression.ColumnElement` subclass. For example, three fixed values can be compared as in:: print(between(5, 3, 7)) Which would produce:: :param_1 BETWEEN :param_2 AND :param_3 :param expr: a column expression, typically a :class:`_expression.ColumnElement` instance or alternatively a Python scalar expression to be coerced into a column expression, serving as the left side of the ``BETWEEN`` expression. :param lower_bound: a column or Python scalar expression serving as the lower bound of the right side of the ``BETWEEN`` expression. :param upper_bound: a column or Python scalar expression serving as the upper bound of the right side of the ``BETWEEN`` expression. :param symmetric: if True, will render " BETWEEN SYMMETRIC ". Note that not all databases support this syntax. .. versionadded:: 0.9.5 .. seealso:: :meth:`_expression.ColumnElement.between` t symmetric(RRRRtbetween(R$t lower_boundt upper_boundR%((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyR&Hs4cCstjtj|d|S(uReturn a literal clause, bound to a bind parameter. Literal clauses are created automatically when non- :class:`_expression.ClauseElement` objects (such as strings, ints, dates, etc.) are used in a comparison operation with a :class:`_expression.ColumnElement` subclass, such as a :class:`~sqlalchemy.schema.Column` object. Use this function to force the generation of a literal clause, which will be created as a :class:`BindParameter` with a bound value. :param value: the value to be bound. Can be any Python object supported by the underlying DB-API, or is translatable via the given type argument. :param type\_: an optional :class:`~sqlalchemy.types.TypeEngine` which will provide bind-parameter translation for this literal. R(RRRtLiteralValueRole(tvalueR((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pytliteralsc Cst|dd|dtdtS(uxCreate an 'OUT' parameter for usage in functions (stored procedures), for databases which support them. The ``outparam`` can be used like a regular function parameter. The "output" value will be available from the :class:`~sqlalchemy.engine.CursorResult` object via its ``out_parameters`` attribute, which returns a dictionary containing the values. Rtuniquet isoutparamN(t BindParametertNonetFalsetTrue(tkeyR((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pytoutparams cCstjtjtj|S(uReturn a negation of the given clause, i.e. ``NOT(clause)``. The ``~`` operator is also overloaded on all :class:`_expression.ColumnElement` subclasses to produce the same result. (RtinvRRRR(tclause((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pytnot_st ClauseElementcBseZdZdZejZeZdZ gZ dZ dZ dZeZeZeZeZeZeZeZeZeZeZeZeZeZeZeZeZeZ dZ!dZ"dZ#dZ$dZ%dZ&e'dZ(e)j*dZ+e'd Z,d Z-ed Z.d Z/d Z0dZ1dZ2ddZ3dZ4ej5dej5ddddZ6ddeddZ7dZ8dZ9dZ:dZ;dZ<e<Z=dZ>RS(uSBase class for elements of a programmatically constructed SQL expression. uclauseudefaultcCstj||_|S(N(Rt immutabledictt_propagate_attrs(tselftvalues((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt_set_propagate_attrssc s|j|jj|j}rOfd|jjjD|_n|jj|_|j}|dk r||n||_|S(uCreate a shallow copy of this ClauseElement. This method may be used by a generative API. Its also used as part of the "deep" copy afforded by a traversal that combines the _copy_internals() method. cs+i|]!\}}|kr||qS(((t.0tktv(tskip(sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pys s N(t_memoized_keyst __class__t__new__t__dict__tcopytitemst _is_clone_ofR/(R:tkwtctcc((R@sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyRs + cCs|S(ua hook to allow the right side of a binary expression to respond to a negation of the binary expression. Used for the special case of expanding bind parameter with IN. ((R:t negated_opt original_op((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt_negate_in_binaryscCs|S(uin the context of binary expression, convert the type of this object to the one given. applies only to :class:`_expression.ColumnElement` classes. ((R:R((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt_with_binary_element_typescCs|jS(u.return the 'constructor' for this ClauseElement. This is for the purposes for creating a new object of this type. Usually, its just the element's __class__. However, the "Annotated" version of the object overrides to return the class of its proxied element. (RB(R:((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt _constructors cCs?tj}|}x&|dk r:|j||j}qW|S(uReturn the set consisting all cloned ancestors of this ClauseElement. Includes this ClauseElement. This accessor tends to be used for FromClause objects to identify 'equivalent' FROM clauses, regardless of transformative operations. N(Rt column_setR/taddRG(R:tstf((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt _cloned_set&s   cCstddS(NuFThis SQL expression has no entity namespace with which to filter from.(tAttributeError(R:((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pytentity_namespace=scCs3|jj}|jdd|jdd|S(Nu _is_clone_ofu_generate_cache_key(RDREtpopR/(R:td((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt __getstate__DscCs8|s|jr%|j||||Stj|dS(N(tsupports_executiont_execute_clauseelementRtObjectNotExecutableError(R:t connectiont multiparamstparamstexecution_optionst_force((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt_execute_on_connectionJscOs|jt||S(uReturn a copy with :func:`_expression.bindparam` elements replaced. Same functionality as :meth:`_expression.ClauseElement.params`, except adds `unique=True` to affected bind parameters so that multiple statements can be used. (t_replace_paramsR1(R:t optionaldicttkwargs((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt unique_paramsTs cOs|jt||S(uReturn a copy with :func:`_expression.bindparam` elements replaced. Returns a copy of this ClauseElement with :func:`_expression.bindparam` elements replaced with values taken from the given dictionary:: >>> clause = column('x') + bindparam('foo') >>> print(clause.compile().params) {'foo':None} >>> print(clause.params({'foo':7}).compile().params) {'foo':7} (RcR0(R:RdRe((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyR_`scst|dkr&j|dn$t|dkrJtjdnfd}t|itd6td6i|d6S(Niiu9params() takes zero or one positional dictionary argumentcsB|jkr+|j|_t|_nr>|jndS(N(R2R*R0trequiredt_convert_to_unique(tbind(ReR,(sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pytvisit_bindparamzs  u maintain_keyudetect_subquery_colsu bindparam(tlentupdateRt ArgumentErrorRR1(R:R,RdReRj((ReR,sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyRcqs cKstj|||S(uCompare this :class:`_expression.ClauseElement` to the given :class:`_expression.ClauseElement`. Subclasses should override the default behavior, which is a straight identity comparison. \**kw are arguments consumed by subclass ``compare()`` methods and may be used to modify the criteria for comparison (see :class:`_expression.ColumnElement`). (Rtcompare(R:totherRH((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyRns cCs|S(uApply a 'grouping' to this :class:`_expression.ClauseElement`. This method is overridden by subclasses to return a "grouping" construct, i.e. parenthesis. In particular it's used by "binary" expressions to provide a grouping around themselves when placed into a larger expression, as well as by :func:`_expression.select` constructs when placed into the FROM clause of another :func:`_expression.select`. (Note that subqueries should be normally created using the :meth:`_expression.Select.alias` method, as many platforms require nested SELECT statements to be named). As expressions are composed together, the application of :meth:`self_group` is automatic - end-user code should never need to use this method directly. Note that SQLAlchemy's clause constructs take operator precedence into account - so parenthesis might not be needed, for example, in an expression like ``x OR (y AND z)`` - AND takes precedence over OR. The base :meth:`self_group` method of :class:`_expression.ClauseElement` just returns self. ((R:tagainst((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt self_groupscCs|S(uVReturn this :class:`_expression.ClauseElement` without any groupings. ((R:((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt_ungroupsusqlalchemy.engine.defaultusqlalchemy.engine.urlcKs|s|r|j}q|jr0|jj}q|jdkrZtjj}|j}qtjj}|jj |jj }n|j ||S(u3Compile this SQL expression. The return value is a :class:`~.Compiled` object. Calling ``str()`` or ``unicode()`` on the returned value will yield a string representation of the result. The :class:`~.Compiled` object also can return a dictionary of bind parameter names and values using the ``params`` accessor. :param bind: An ``Engine`` or ``Connection`` from which a ``Compiled`` will be acquired. This argument takes precedence over this :class:`_expression.ClauseElement`'s bound engine, if any. :param column_keys: Used for INSERT and UPDATE statements, a list of column names which should be present in the VALUES clause of the compiled statement. If ``None``, all columns from the target table object are rendered. :param dialect: A ``Dialect`` instance from which a ``Compiled`` will be acquired. This argument takes precedence over the `bind` argument as well as this :class:`_expression.ClauseElement` 's bound engine, if any. :param compile_kwargs: optional dictionary of additional parameters that will be passed through to the compiler within all "visit" methods. This allows any custom flag to be passed through to a custom compilation construct, for example. It is also used for the case of passing the ``literal_binds`` flag through:: from sqlalchemy.sql import table, column, select t = table('t', column('x')) s = select(t).where(t.c.x == 5) print(s.compile(compile_kwargs={"literal_binds": True})) .. versionadded:: 0.9.0 .. seealso:: :ref:`faq_sql_expression_string` udefault( tdialectRitstringify_dialectRt preloadedtengine_defaulttStrCompileDialectt engine_urltURLtcreatet get_dialectt _compiler(R:RiRsRHtdefaultturl((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pytcompiles1     c Ks7|dk r$|jr$|j}nd}|r|\}} ||t|t||f} |j| } | dkr|j} |j|d|d|d|d||} | || (t descriptionR/tobjectt__repr__t __module__RBt__name__tid(R:tfriendly((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyRSs     N(?RRt__doc__t__visit_name__RR8R9R0RZRtt _from_objectsR/RiRRGR1tis_clause_elementt is_selectablet!_gen_static_annotations_cache_keyt _is_tablet _is_textualt_is_from_clauset_is_returns_rowst_is_text_clauset_is_from_containert_is_select_containert_is_select_statementt_is_bind_parametert_is_clause_listt_is_lambda_elementt_is_singleton_constantt _is_immutablet_is_start_order_by_label_elementt_cache_key_traversalR<RRMRNtpropertyROR tmemoized_attributeRTRVRYRbRfR_RcRnRqRrtpreload_moduleRRR|RRRRt __nonzero__R(((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyR7sr             C 4     t ColumnElementcBsBeZdZdZeZgZd'Zd(Z d(Z e j dZ edZedZedZeZeZeZd)Zd(dZdZejdZe j d Zd Zd Zd Zd Z d(edZ!edZ"edZ#ejdZ$ejdZ%dZ&dZ'dZ(e j dZ)e j dZ*d(d(edZ+dZ,dZ-d(dZ.ejdZ/ejdZ0eej1ddd Z2eej1dd!d"Z3d#Z4ejd$Z5ejd%Z6d&Z7RS(*uRepresent a column-oriented SQL expression suitable for usage in the "columns" clause, WHERE clause etc. of a statement. While the most familiar kind of :class:`_expression.ColumnElement` is the :class:`_schema.Column` object, :class:`_expression.ColumnElement` serves as the basis for any unit that may be present in a SQL expression, including the expressions themselves, SQL functions, bound parameters, literal expressions, keywords such as ``NULL``, etc. :class:`_expression.ColumnElement` is the ultimate base class for all such elements. A wide variety of SQLAlchemy Core functions work at the SQL expression level, and are intended to accept instances of :class:`_expression.ColumnElement` as arguments. These functions will typically document that they accept a "SQL expression" as an argument. What this means in terms of SQLAlchemy usually refers to an input which is either already in the form of a :class:`_expression.ColumnElement` object, or a value which can be **coerced** into one. The coercion rules followed by most, but not all, SQLAlchemy Core functions with regards to SQL expressions are as follows: * a literal Python value, such as a string, integer or floating point value, boolean, datetime, ``Decimal`` object, or virtually any other Python object, will be coerced into a "literal bound value". This generally means that a :func:`.bindparam` will be produced featuring the given value embedded into the construct; the resulting :class:`.BindParameter` object is an instance of :class:`_expression.ColumnElement`. The Python value will ultimately be sent to the DBAPI at execution time as a parameterized argument to the ``execute()`` or ``executemany()`` methods, after SQLAlchemy type-specific converters (e.g. those provided by any associated :class:`.TypeEngine` objects) are applied to the value. * any special object value, typically ORM-level constructs, which feature an accessor called ``__clause_element__()``. The Core expression system looks for this method when an object of otherwise unknown type is passed to a function that is looking to coerce the argument into a :class:`_expression.ColumnElement` and sometimes a :class:`_expression.SelectBase` expression. It is used within the ORM to convert from ORM-specific objects like mapped classes and mapped attributes into Core expression objects. * The Python ``None`` value is typically interpreted as ``NULL``, which in SQLAlchemy Core produces an instance of :func:`.null`. A :class:`_expression.ColumnElement` provides the ability to generate new :class:`_expression.ColumnElement` objects using Python expressions. This means that Python operators such as ``==``, ``!=`` and ``<`` are overloaded to mimic SQL operations, and allow the instantiation of further :class:`_expression.ColumnElement` instances which are composed from other, more fundamental :class:`_expression.ColumnElement` objects. For example, two :class:`.ColumnClause` objects can be added together with the addition operator ``+`` to produce a :class:`.BinaryExpression`. Both :class:`.ColumnClause` and :class:`.BinaryExpression` are subclasses of :class:`_expression.ColumnElement`:: >>> from sqlalchemy.sql import column >>> column('a') + column('b') >>> print(column('a') + column('b')) a + b .. seealso:: :class:`_schema.Column` :func:`_expression.column` ucolumn_elementcCs|jS(ulA label-based version of 'key' that in some circumstances refers to this object in a Python namespace. _tq_key_label comes into play when a select() statement is constructed with apply_labels(); in this case, all Column objects in the ``.c`` collection are rendered as _ in SQL; this is essentially the value of ._label. But to locate those columns in the ``.c`` collection, the name is along the lines of _; that's the typical value of .key_label. .. versionchanged:: 1.4.21 renamed from ``._key_label`` (t _proxy_key(R:((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt _tq_key_labelscCs|jS(u legacy; renamed to _tq_key_label(R(R:((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt _key_labelscCs|jS(ulegacy; renamed to _tq_label(t _tq_label(R:((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt_labelscCst|ddS(u:the 'name' that naturally applies this element when rendered in SQL. Concretely, this is the "name" of a column or a label in a SELECT statement; ```` and ```` below:: SELECT FROM table SELECT column AS FROM table Above, the two names noted will be what's present in the DBAPI ``cursor.description`` as the names. If this attribute returns ``None``, it means that the SQL element as written does not have a 100% fully predictable "name" that would appear in the ``cursor.description``. Examples include SQL functions, CAST functions, etc. While such things do return names in ``cursor.description``, they are only predictable on a database-specific basis; e.g. an expression like ``MAX(table.col)`` may appear as the string ``max`` on one database (like PostgreSQL) or may appear as the whole expression ``max(table.col)`` on SQLite. The default implementation looks for a ``.name`` attribute on the object, as has been the precedent established in SQLAlchemy for many years. An exception is made on the ``FunctionElement`` subclass so that the return value is always ``None``. .. versionadded:: 1.4.21 unameN(tgetattrR/(R:((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt_non_anon_labels"cCsv|tjtjtjfkrL|jjtjjkrLt|tj tj S|tj tj fkrnt |S|SdS(N(Rtand_tor_t_asboolR!t_type_affinityRt BOOLEANTYPEt AsBooleantis_truetis_falsetany_optall_optGrouping(R:Rp((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyRq1s  cCsE|jjtjjkr.t|tjtjStt |j SdS(N( R!RRRRRRRtsuperRR(R:((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyR<scCstjS(N(RtNULLTYPE(R:((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyR!BscCsTy|jj}Wn3tk rE}tjtd|jd|n X||SdS(NuOObject %r associated with '.type' attribute is not a TypeEngine class or objecttreplace_context(R!tcomparator_factoryRURtraise_R(R:Rterr((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt comparatorFs  cCs|jj|dS(N(RDRl(R:tstate((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt __setstate__UscCsiyt|j|SWnNtk rd}tjtdt|jt|jj|fd|nXdS(Nu3Neither %r object nor %r object has an attribute %rR(RRRURRR!R(R:R2R((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt __getattr__Xs  cOs||j||S(N(R(R:topRoRe((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pytoperatehscKs|||j|S(N(R(R:RRoRe((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pytreverse_operateksc Cs.td|d|d|d|jdtd|S(Nt_compared_to_operatorRt_compared_to_typeR,t expanding(R.R/R!R1(R:RtobjRR((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt _bind_paramns cCs|S(u^Return a column expression. Part of the inspection interface; returns self. ((R:((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyR"yscCs|fS(N((R:((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt_select_iterablescCstjd|jDS(Ncss|]}|js|VqdS(N(t_proxies(R=RI((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pys s(RRPt proxy_set(R:((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt base_columnsscCs@tj|jg}x!|jD]}|j|jq"W|S(N(RRPt _deannotateRRlR(R:RRRI((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyRscCs4|g}x$|jD]}|j|jqW|S(uAn 'uncached' version of proxy set. This is so that we can read annotations from the list of columns without breaking the caching of the above proxy_set. (Rtextendt_uncached_proxy_list(R:RRRI((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyRs cCst|jj|jS(uReturn True if the given :class:`_expression.ColumnElement` has a common ancestor to this :class:`_expression.ColumnElement`.(RRt intersection(R:t othercolumn((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pytshares_lineagescCs.t|do-t|do-|j|jkS(uhReturn True if the given column element compares to this one when targeting within a result row.uname(Rtname(R:Ro((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyt_compare_name_for_resultscCsY|jr#d|jkr#|jdS|j}|s>|j}nt|trQdS|SdS(Nu proxy_key(t _annotationsR2Rt isinstancet_anonymous_labelR/(R:R((sJ/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyRs   cCsGt|dddk rdS|jr?d|jkr?|jdSdSdS(u\a suggested label to use in the case that the column has no name, which should be used if possible as the explicit 'AS