.. _l-methods: Methods ======= .. contents:: :local: :depth: 1 Summary +++++++ +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | method | class parent | truncated documentation | +===============================================================================================================+=====================+===================================================================================================================+ | :meth:`And ` | CFT | ``and`` cannot be overriden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`And ` | ColumnConstantType | ``and`` cannot be overriden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`And ` | ColumnGroupType | ``and`` cannot be overriden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`And ` | ColumnTableType | ``and`` cannot be overriden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`And ` | ColumnType | ``and`` cannot be overriden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`Code ` | TranslateClass | Returns the code of the initial Python function into another language. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`GroupBy ` | Translate2Python | Interprets a select statement. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`Intruction ` | TranslateClass | Builds an instruction of a function based on its name and its children. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`IsColumnType ` | CFT | checks it is a column type which used by an operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`IsColumnType ` | ColumnConstantType | checks it is a column type which used by an operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`IsColumnType ` | ColumnGroupType | checks it is a column type which used by an operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`IsColumnType ` | ColumnTableType | checks it is a column type which used by an operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`IsColumnType ` | ColumnType | checks it is a column type which used by an operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`Not ` | CFT | ``not`` cannot be overriden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`Not ` | ColumnConstantType | ``not`` cannot be overriden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`Not ` | ColumnGroupType | ``not`` cannot be overriden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`Not ` | ColumnTableType | ``not`` cannot be overriden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`Not ` | ColumnType | ``not`` cannot be overriden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`Or ` | CFT | ``or`` cannot be overriden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`Or ` | ColumnConstantType | ``or`` cannot be overriden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`Or ` | ColumnGroupType | ``or`` cannot be overriden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`Or ` | ColumnTableType | ``or`` cannot be overriden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`Or ` | ColumnType | ``or`` cannot be overriden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`RaiseCodeException ` | TranslateClass | Raises an exception when interpreting the code. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`ResolveExpression ` | TranslateClass | Produces an expression based on a a node and its children. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`Select ` | TranslateClass | Interprets a select statement. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`Select ` | Translate2Python | Interprets a select statement. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`Signature ` | TranslateClass | Build the signature of a function based on its name and its children. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`Signature ` | Translate2Python | Builds the signature of a function based on its name and its children. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`Where ` | TranslateClass | Interprets a select statement. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`Where ` | Translate2Python | Interprets a where statement. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__add__ ` | CFT | These operators should be able to translate an expression into function operating on the values. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__add__ ` | ColumnConstantType | These operators should be able to translate an expression into function operating on the values. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__add__ ` | ColumnGroupType | forbidden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__add__ ` | ColumnTableType | These operators should be able to translate an expression into function operating on the values. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__add__ ` | ColumnType | These operators should be able to translate an expression into function operating on the values. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__add__ ` | NA | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__add__ ` | long | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__and__ ` | CFT | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__and__ ` | ColumnConstantType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__and__ ` | ColumnGroupType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__and__ ` | ColumnTableType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__and__ ` | ColumnType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | ColumnGroupOperator | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | OperatorGroupAvg | returns the results of this operation between a list of columns, it returns :class:`NA` for a null set | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | OperatorGroupLen | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | ColumnOperator | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | OperatorAdd | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | OperatorAnd | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | OperatorDiv | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | OperatorDivN | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | OperatorEq | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | OperatorFunc | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | OperatorGe | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | OperatorGt | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | OperatorId | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | OperatorLe | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | OperatorLt | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | OperatorMod | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | OperatorMul | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | OperatorNe | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | OperatorNot | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | OperatorOr | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | OperatorPow | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | OperatorSub | returns the results of this operation between a list of columns | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | CFT | returns func(value) | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | ColumnConstantType | return the constant | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | ColumnGroupType | returns the content | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | ColumnTableType | returns the content | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | ColumnType | returns func(value) | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__call__ ` | IterRow | evaluate | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__div__ ` | NA | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__div__ ` | long | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__eq__ ` | CFT | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__eq__ ` | ColumnConstantType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__eq__ ` | ColumnGroupType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__eq__ ` | ColumnTableType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__eq__ ` | ColumnType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__float__ ` | long | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__floordiv__ ` | CFT | These operators should be able to translate an expression into function operating on the values. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__floordiv__ ` | ColumnConstantType | These operators should be able to translate an expression into function operating on the values. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__floordiv__ ` | ColumnGroupType | forbidden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__floordiv__ ` | ColumnTableType | These operators should be able to translate an expression into function operating on the values. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__floordiv__ ` | ColumnType | These operators should be able to translate an expression into function operating on the values. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__ge__ ` | CFT | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__ge__ ` | ColumnConstantType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__ge__ ` | ColumnGroupType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__ge__ ` | ColumnTableType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__ge__ ` | ColumnType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__gt__ ` | CFT | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__gt__ ` | ColumnConstantType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__gt__ ` | ColumnGroupType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__gt__ ` | ColumnTableType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__gt__ ` | ColumnType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | ColumnGroupOperator | Initiates the operator. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | OperatorGroupAvg | Initiates the operator. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | OperatorGroupLen | Initiates the operator. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | ColumnOperator | initiates the operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | OperatorAdd | initiates the operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | OperatorAnd | initiates the operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | OperatorDiv | initiates the operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | OperatorDivN | initiates the operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | OperatorEq | initiates the operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | OperatorFunc | constructor | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | OperatorGe | initiates the operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | OperatorGt | initiates the operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | OperatorId | initiates the operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | OperatorLe | initiates the operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | OperatorLt | initiates the operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | OperatorMod | initiates the operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | OperatorMul | initiates the operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | OperatorNe | initiates the operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | OperatorNot | initiates the operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | OperatorOr | initiates the operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | OperatorPow | initiates the operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | OperatorSub | initiates the operator | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | CFT | constructor (a function cannot accept keywords) | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | ColumnConstantType | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | ColumnGroupType | constructor | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | ColumnTableType | constructor | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | ColumnType | initiates the column | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | IterRow | Initializes the iterator. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | EmptyGroup | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | NA | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | NoSortClass | any value | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | long | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | CodeNodeVisitor | constructor | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | TranslateClass | Constructor. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | Translate2Python | constructor | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__int__ ` | long | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__iter__ ` | IterRow | iterator, returns this row, it always outputs a list of list | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__le__ ` | CFT | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__le__ ` | ColumnConstantType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__le__ ` | ColumnGroupType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__le__ ` | ColumnTableType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__le__ ` | ColumnType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__lt__ ` | CFT | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__lt__ ` | ColumnConstantType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__lt__ ` | ColumnGroupType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__lt__ ` | ColumnTableType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__lt__ ` | ColumnType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__lt__ ` | NoSortClass | operator __lt__ | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__mod__ ` | CFT | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__mod__ ` | ColumnConstantType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__mod__ ` | ColumnGroupType | forbidden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__mod__ ` | ColumnTableType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__mod__ ` | ColumnType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__mul__ ` | CFT | These operators should be able to translate an expression into function operating on the values. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__mul__ ` | ColumnConstantType | These operators should be able to translate an expression into function operating on the values. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__mul__ ` | ColumnGroupType | forbidden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__mul__ ` | ColumnTableType | These operators should be able to translate an expression into function operating on the values. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__mul__ ` | ColumnType | These operators should be able to translate an expression into function operating on the values. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__mul__ ` | NA | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__mul__ ` | long | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__ne__ ` | CFT | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__ne__ ` | ColumnConstantType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__ne__ ` | ColumnGroupType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__ne__ ` | ColumnTableType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__ne__ ` | ColumnType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__not__ ` | CFT | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__not__ ` | ColumnConstantType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__not__ ` | ColumnGroupType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__not__ ` | ColumnTableType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__not__ ` | ColumnType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__or__ ` | CFT | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__or__ ` | ColumnConstantType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__or__ ` | ColumnGroupType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__or__ ` | ColumnTableType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__or__ ` | ColumnType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__pow__ ` | CFT | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__pow__ ` | ColumnConstantType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__pow__ ` | ColumnGroupType | forbidden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__pow__ ` | ColumnTableType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__pow__ ` | ColumnType | these operators should be able to translate an expression into function operating on the values | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | ColumnGroupOperator | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | OperatorGroupAvg | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | OperatorGroupLen | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | ColumnOperator | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | OperatorAdd | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | OperatorAnd | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | OperatorDiv | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | OperatorDivN | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | OperatorEq | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | OperatorFunc | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | OperatorGe | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | OperatorGt | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | OperatorId | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | OperatorLe | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | OperatorLt | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | OperatorMod | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | OperatorMul | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | OperatorNe | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | OperatorNot | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | OperatorOr | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | OperatorPow | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | OperatorSub | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | CFT | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | ColumnConstantType | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | ColumnGroupType | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | ColumnTableType | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | ColumnType | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | IterRow | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | NoSortClass | usual | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | long | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | TranslateClass | Returns a string representing a tree. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__sub__ ` | CFT | These operators should be able to translate an expression into function operating on the values. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__sub__ ` | ColumnConstantType | These operators should be able to translate an expression into function operating on the values. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__sub__ ` | ColumnGroupType | forbidden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__sub__ ` | ColumnTableType | These operators should be able to translate an expression into function operating on the values. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__sub__ ` | ColumnType | These operators should be able to translate an expression into function operating on the values. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__sub__ ` | NA | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__sub__ ` | long | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__truediv__ ` | CFT | These operators should be able to translate an expression into function operating on the values. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__truediv__ ` | ColumnConstantType | These operators should be able to translate an expression into function operating on the values. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__truediv__ ` | ColumnGroupType | forbidden | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__truediv__ ` | ColumnTableType | These operators should be able to translate an expression into function operating on the values. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__truediv__ ` | ColumnType | These operators should be able to translate an expression into function operating on the values. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_findschema ` | IterRow | look for column index whose name is name | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`avg ` | CFT | returns a group columns to return an average | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`avg ` | ColumnConstantType | returns a group columns to return an average | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`avg ` | ColumnGroupType | returns a group columns to return an average | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`avg ` | ColumnTableType | returns a group columns to return an average | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`avg ` | ColumnType | returns a group columns to return an average | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`copy ` | CFT | Returns a copy of this class. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`copy ` | ColumnConstantType | Returns a copy of this class. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`copy ` | ColumnGroupType | Returns a copy of this class. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`copy ` | ColumnTableType | Returns a copy of this class. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`copy ` | ColumnType | Returns a copy of this class. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`count ` | CFT | returns a group columns to count the number of observations | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`count ` | ColumnConstantType | returns a group columns to count the number of observations | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`count ` | ColumnGroupType | returns a group columns to count the number of observations | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`count ` | ColumnTableType | returns a group columns to count the number of observations | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`count ` | ColumnType | returns a group columns to count the number of observations | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`generic_visit ` | CodeNodeVisitor | Overrides ``generic_visit`` to check it is not used. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`generic_visit_args ` | CodeNodeVisitor | Overrides ``generic_visit`` to keep track of the indentation and the node parent. The function will add field ... | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`groupby ` | IterRow | This function applies a groupby (same behavior as SQL's version) | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`init ` | TranslateClass | Parses the function code and add it the class, it complements the constructor. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`interpretFunction ` | TranslateClass | Starts the interpretation of node which begins a function. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`interpretReturn ` | TranslateClass | Starts the interpretation of a node which sets a return. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`len ` | CFT | returns a group columns to count the number of observations | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`len ` | ColumnConstantType | returns a group columns to count the number of observations | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`len ` | ColumnGroupType | returns a group columns to count the number of observations | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`len ` | ColumnTableType | returns a group columns to count the number of observations | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`len ` | ColumnType | returns a group columns to count the number of observations | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`orderby ` | IterRow | This function sorts elements from an IterRow instance. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`print_parent ` | CFT | Returns a string showing the dependencies of this columns. Example | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`print_parent ` | ColumnConstantType | Returns a string showing the dependencies of this columns. Example | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`print_parent ` | ColumnGroupType | Returns a string showing the dependencies of this columns. Example | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`print_parent ` | ColumnTableType | Returns a string showing the dependencies of this columns. Example | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`print_parent ` | ColumnType | Returns a string showing the dependencies of this columns. Example | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`print_schema ` | IterRow | calls :meth:`print_parent` on each column | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`print_tree ` | CodeNodeVisitor | Displays the tree of instructions. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`push ` | CodeNodeVisitor | Pushes an element into a list. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`select ` | IterRow | This function takes an undefined number of arguments. It can be used the following way: | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`set ` | CFT | Sets a value for this column. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`set ` | ColumnConstantType | do nothing (it is a constant) | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`set ` | ColumnGroupType | sets a value for this column | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`set ` | ColumnTableType | Sets a value for this column. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`set ` | ColumnType | Sets a value for this column. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`setReturn ` | TranslateClass | Indicates all nodes containing information about returned results. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`setReturn ` | Translate2Python | Indicates all nodes containing information about returned results. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`set_name ` | CFT | Changes the name of the column. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`set_name ` | ColumnConstantType | Changes the name of the column. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`set_name ` | ColumnGroupType | Changes the name of the column. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`set_name ` | ColumnTableType | Changes the name of the column. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`set_name ` | ColumnType | Changes the name of the column. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`set_none ` | CFT | after a loop on a database, we should put None back as a value | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`set_none ` | ColumnConstantType | do nothing (it is a constant) | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`set_none ` | ColumnGroupType | after a loop on a database, we should put None back as a value | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`set_none ` | ColumnTableType | after a loop on a database, we should put None back as a value | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`set_none ` | ColumnType | After a loop on a database, we should put None back as a value. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`set_owner ` | CFT | Changes the owner of the column. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`set_owner ` | ColumnConstantType | Changes the owner of the column. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`set_owner ` | ColumnGroupType | Changes the owner of the column. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`set_owner ` | ColumnTableType | Changes the owner of the column. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`set_owner ` | ColumnType | Changes the owner of the column. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`to_str ` | TranslateClass | Returns a string representing a tree. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`unionall ` | IterRow | Concatenates this table with another one | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit ` | CodeNodeVisitor | Visits a node, a method must exist for every object class. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit_ ` | CodeNodeVisitor | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit_Assign ` | CodeNodeVisitor | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit_Attribute ` | CodeNodeVisitor | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit_BinOp ` | CodeNodeVisitor | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit_Call ` | CodeNodeVisitor | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit_Compare ` | CodeNodeVisitor | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit_FunctionDef ` | CodeNodeVisitor | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit_Gt ` | CodeNodeVisitor | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit_Load ` | CodeNodeVisitor | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit_Lt ` | CodeNodeVisitor | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit_Module ` | CodeNodeVisitor | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit_Mult ` | CodeNodeVisitor | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit_Name ` | CodeNodeVisitor | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit_Num ` | CodeNodeVisitor | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit_Return ` | CodeNodeVisitor | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit_Store ` | CodeNodeVisitor | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit_Str ` | CodeNodeVisitor | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit_arg ` | CodeNodeVisitor | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit_arguments ` | CodeNodeVisitor | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`visit_keyword ` | CodeNodeVisitor | | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+ | :meth:`where ` | IterRow | This function filters elements from an :class:`IterRow` instance. | +---------------------------------------------------------------------------------------------------------------+---------------------+-------------------------------------------------------------------------------------------------------------------+