ichorORM.query
index

Copyright (c) 2016-2018 Timothy Savannah
 
Licensed under the terms of the Lesser GNU Lesser General Public License version 2.1
 
  license can be found at https://raw.githubusercontent.com/kata198/ichorORM/master/LICENSE
 
 
query - A lot of abstraction and whatnot related to various SQL commands

 
Modules
       
copy
datetime
re

 
Classes
       
builtins.object
FilterType
FilterField
FilterJoin
FilterStage
QueryBase
DeleteQuery
InsertQuery
SelectQuery
SelectGenericJoinQuery
SelectInnerJoinQuery
UpdateQuery
builtins.str(builtins.object)
ichorORM.special.QueryStr

 
class DeleteQuery(QueryBase)
    DeleteQuery - Perform a delete
 
 
Method resolution order:
DeleteQuery
QueryBase
builtins.object

Methods defined here:
__init__(self, model, filterStages=None)
__init__ - Create a DeleteQuery
 
  @param model - The model class
execute(self, dbConn=None, doCommit=True)
execute - Execute this action, generic method.
 
        For SelectQuery, will call executeDelete
 
    @param dbConn <DatabaseConnection/None> Default None - If None, start a new connection
            using the global connection settings. Otherwise, use given connection.
 
    @param doCommit <bool> Default True - If True, will commit right away. If False, you must commit.
 
        A #dbConn must be specified if doCommit=False
executeDelete(self, dbConn=None, doCommit=True)
executeDelete - Perform the delete. (parameterized)
 
    will NOT execute anything if conditionals are not set, to prevent accidently wiping the entire DB.
 
  @param dbConn <DatabaseConnection> - Connect to use, like for transaction
 
  @param doCommit <bool> default True - If True will perform the delete right away.
 
        If False, you must manually commit the transaction and a #dbConn is required
executeDeleteRaw(self, dbConn=None, doCommit=True)
executeDelete - Perform the delete. (non-parameterized)
 
    will NOT execute anything if conditionals are not set, to prevent accidently wiping the entire DB.
 
  @param dbConn <DatabaseConnection/None> Default None - Connect to use, like for transaction.
 
        If None, default settings will be used with a new connection
 
  @param doCommit <bool> default True - If True will perform the delete right away.
 
        If False, you must manually commit the transaction and a #dbConn is required
getSql(self)
getSql - Get the SQL to execute
getSqlParameterizedValues(self, paramPrefix='')
getSqlParameterizedValues - Get SQL with parameterized values
 
    @param paramPrefix <str> Default '' - If provided, will prefix params with paramPrefix + "_"

Methods inherited from QueryBase:
addStage(self, _filter='AND')
addStage - Add a "stage" to the WHERE condition. A stage is a collection of conditional expressions.
 
  @param _filter:
    <str>  -  Default WHERE_AND - WHERE_AND or WHERE_OR , this specifies the relation of the various
             conditionals in this stage,
             i.e. if it should be ( conA AND conB AND conC )   or  ( conA OR conB OR conC )
 
    <FilterStage> - Adds a FilterStage directly
 
   @return - The FilterStage created by calling this method (just add to it, and it will automatically be linked),
            or if a FilterStage was passed it will be returned
getAllFieldNames(self)
getAllFieldNames - Get a list of all the fields on this table
 
  @return list<str> - List of all fields on model
getModel(self)
getModel - Gets the model <DatabaseModel> associated with this Query.
 
    NOTE: Not all queries have the same meaning here.
      For example, a SelectInnerJoinQuery
        has no "model" set but a list of "models" ( @see #getModels ).
      On a SelectGenericJoinQuery this returns the "primary" model, while #getModels returns all models.
 
      @return <DatabaseModel/None> - The "primary" model associated with this query if applicable
getModels(self)
getModels - Gets a list of the models <DatabaseModel> associated with this Query.
 
    NOTE: The meaning of the query comes into play here.
      For example, an InsertQuery would return a list of [ self.getModel() ].
      A SelectGenericJoinQuery would return all the applicable models
 
      @return list<DatabaseModel> - A list of alll models associated with this query
getTableName(self)
getTableName - Get the name of the table associated with this model
 
  @return <str> - Table Name
getWhereClause(self, whereJoin='AND')
getWhereClause - Gets the "WHERE" portion (including the string 'WHERE'), including all stages and sub-stages
 
  @param whereJoin - If there are multiple top-level filter stages on this Query, this is how they should be related to eachother,
    via AND or OR.
 
    Generally, it makes more sense to just add a single filter stage at the top level, and append additional stages onto that.
 
 @return <str> - The WHERE clause, or empty string if no conditions are present
getWhereClauseParams(self, whereJoin='AND', paramPrefix='')
getWhereClauseParams - Gets the "WHERE" portion (including the string 'WHERE'), parameterized and the parameters
 
    @param whereJoin <WHERE_AND/WHERE_OR> - Either 'AND' or 'OR', what will join the various conditions in this clause
 
    @param paramPrefix <str> Default '' - If not empty string, paramPrefix + "_" will be prepended to all parameters
 
  @see getWhereClause

Data descriptors inherited from QueryBase:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class FilterField(FilterType)
    FilterField - A single condition on a field
 
 
Method resolution order:
FilterField
FilterType
builtins.object

Methods defined here:
__init__(self, filterName, filterType, filterValue, operator=None)
__init__ - Create a FilterField (conditional)
 
    @param filterName <str> - Field name
 
    @param filterType <str> - Operation ( like "=" )
 
    @param filterValue <str/QueryStr/SelectQuery> - The value to match, or a query to embed to fetch value
 
    @param operator <str/None> default None - If provided, will use
        
        this as the operator, otherwise will calculate from #filterType
getFilterValue(self)
getFilterValue - Get the value of this filter
 
@return <str> - Value of this filter
toStr(self)
toStr - Convert this into a single boolean expression for a SQL query.
 
  Recommended to use #toStrParam for quoting / injection reasons
toStrParam(self, paramName)
toStrParam - Convert this into a single boolean expression for SQL query,
  with using a parameterized value
 
@param paramName <str> - A unique name for this value
 
@return tuple( <str>, <dict> ) - A tuple of the param str (for appending to SQL query), and
   a dict of the paramNames -> paramValues, for passing into parameterization

Data descriptors defined here:
filterName
filterType
filterValue
operator

Data descriptors inherited from FilterType:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class FilterJoin(FilterField)
    FilterJoin - A filter expression which performs a join.
 
    Does NOT quote, both sides are expected to be fields.
 
 
Method resolution order:
FilterJoin
FilterField
FilterType
builtins.object

Methods defined here:
toStr(self)
toStr - Convert this into a single boolean expression for a SQL query
toStrParam(self, paramName)
toStrParam - Convert to a boolean expression for SQL query, parameterized
 
  for FilterJoin this is the same as toStr, params will always be blank

Methods inherited from FilterField:
__init__(self, filterName, filterType, filterValue, operator=None)
__init__ - Create a FilterField (conditional)
 
    @param filterName <str> - Field name
 
    @param filterType <str> - Operation ( like "=" )
 
    @param filterValue <str/QueryStr/SelectQuery> - The value to match, or a query to embed to fetch value
 
    @param operator <str/None> default None - If provided, will use
        
        this as the operator, otherwise will calculate from #filterType
getFilterValue(self)
getFilterValue - Get the value of this filter
 
@return <str> - Value of this filter

Data descriptors inherited from FilterField:
filterName
filterType
filterValue
operator

Data descriptors inherited from FilterType:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class FilterStage(FilterType)
    FilterStage - A filter stage, i.e. a grouping of conditions for the WHERE clause
 
 
Method resolution order:
FilterStage
FilterType
builtins.object

Methods defined here:
__init__(self, whereType='AND', filters=None)
__init__ - Create a FilterStage, defining a paticular "stage" of filtering
 
  Surrounded in parenthesis, with the various parts being joined by #whereType.
 
    @param whereType <str> , default "AND" [ WHERE_AND ] - This will join the various filter parts together
 
    @param filters <None/list <FilterField/FilterStage>> - None, or a list of either FilterField's or FilterStage's
__len__(self)
add = addFilter(self, _filter)
addCondition(self, filterName, filterType, filterValue)
addCondition - Adds a filter, except takes the parameters of a FilterField as arguments
 
  @return - The FilterField that was created and added
 
@see FilterField
addFilter(self, _filter)
addFilter/append/add - Add a filter.
 
@param _filter < FilterField > - A FilterField object which has a field name, comparison operation, and matching value
addJoin(self, leftName, filterType, rightName)
addJoin - Adds a FilterJoin, which is a condition which results in an inner join
 
  @return - The FilterJoin that was created and added
 
@see FilterField
@see FilterJoin
addStage(self, whereType='AND')
addStage - Add a sub stage to this query (like to AND together sets of multi-field OR filters)
 
@param whereType <str> - AND or OR
append = addFilter(self, _filter)
index(self, val)
index - Get the index of the first match of a given filter
 
    @param val <FilterType obj> - Filter to search for
 
    @return <int> - First index of given filter
pop(self, idx)
pop - Remove and return a filter by index
 
    @param idx <int> - The index to pop
 
    @return <FilterType obj> - The filter popped
remove = removeFilter(self, _filter)
removeFilter(self, _filter)
removeFilter - Remove a filter from the list of filters.
 
    @param _filter <FilterType obj> - The filter to remove
    
    @return <None/FilterType obj> - The filter removed, or None if not found.
rindex(self, val)
rindex - Get the index of the last match of a given filter
 
    @param val <FilterType obj> - Filter to search for
 
    @return <int> - Last index of given filter
toStr(self)
toStr - Convert this stage into a grouped boolean expression, including any nested stages.
toStrParam(self, paramPrefix)
toStrParam - Convert to a parameterized string.
 
@return tuple ( <str>, <dict> ) - The SQL string, and parameter dict

Data descriptors defined here:
filters
whereType

Data descriptors inherited from FilterType:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class FilterType(builtins.object)
    FilterType - Base class of filters
 
  Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class InsertQuery(QueryBase)
    InsertQuery - A query builder class for doing inserts
 
 
Method resolution order:
InsertQuery
QueryBase
builtins.object

Methods defined here:
__init__(self, model, initialFieldValues=None, filterStages=None)
__init__ - Create an insert query
 
  @param model <DatabaseModel> - The model to use
 
  @param initialFieldValues <None / dict< str : ??? > > Default None - 
    
    If provided, must be a map to fieldName : fieldValue, and this will become the
     initial set of fields to be set on the inserted object.
 
     Providing this is the same as calling #setFieldValues(initialFieldValues)
execute(self, dbConn=None, doCommit=True)
execute - Execute this action, generic method.
 
        For SelectQuery, will call executeInsert
 
    @param dbConn <DatabaseConnection/None> Default None - If None, start a new connection
            using the global connection settings. Otherwise, use given connection.
 
    @param doCommit <bool> Default True - If True, will commit right away. If False, you must commit.
 
        A #dbConn must be specified if doCommit=False
executeInsert(self, dbConn=None, doCommit=True, returnPk=True)
executeInsert - Insert records (parameterized)
 
    May potentially use an existing DatabaseConnection (for transaction)
 
@param dbConn <None/DatabaseConnection> - If None, will use a fresh connection and auto-commit.
   Otherwise, will use the provided connection (which may be linked to a transaction
 
@param doCommit <bool> default True - Whether to commit immediately
 
 
@see executeInsert for the non-parameterized version.
executeInsertRawValues(self, dbConn=None, doCommit=True)
executeInsertRawValues - Insert records  (non-parameterized)
 
  May potentially use an existing DatabaseConnection (for transaction)
 
@param dbConn <None/DatabaseConnection> - If None, will use a fresh connection and auto-commit.
   Otherwise, will use the provided connection (which may be linked to a transaction
 
@param doCommit <bool> default True - Whether to commit immediately
 
 
@see executeInsertParameterized for the parameterized version.
getInsertValuesStr(self)
getInsertValuesStr - Get the portion following VALUES with values directly within (not parameterized)
getSql(self)
getSql - Get the SQL to execute, non-parameterized
 
@see getSqlParameterizedValues for parameterized version
getSqlParameterizedValues(self)
getSqlParameterizedValues - Get the SQL to execute, parameterized version
getTableFieldParamsAndValues(self)
getTableFieldParamsAndValues - For parameterized values,
 
    This returns a tuple of two values, the first is the paramertized marker to be used in the query,
      the second is a list of values which should be passed alongside
getTableFields(self)
getTableFields - Get a list of the fields that are going to be set
getTableFieldsStr(self)
getTableFieldsStr - Get the portion following the table name in an INSERT query which specifies
                        the fields that will be set
setFieldValue(self, fieldName, newValue)
setFieldValue - Set a field to a value to be inserted
 
    @param fieldName <str> - The name of the field to set (should be in FIELDS array)
 
    @param newValue <???> - The value to insert. Can be a str, number, datetime object, etc. depending on schema
setFieldValues(self, fieldNameToValueMap)
setFieldValues - Set multiple field values
 
    @param fieldNameToValueMap dict<str : ???> - A map of field name -> field value
        
        This will define the values of the fields upon insert

Methods inherited from QueryBase:
addStage(self, _filter='AND')
addStage - Add a "stage" to the WHERE condition. A stage is a collection of conditional expressions.
 
  @param _filter:
    <str>  -  Default WHERE_AND - WHERE_AND or WHERE_OR , this specifies the relation of the various
             conditionals in this stage,
             i.e. if it should be ( conA AND conB AND conC )   or  ( conA OR conB OR conC )
 
    <FilterStage> - Adds a FilterStage directly
 
   @return - The FilterStage created by calling this method (just add to it, and it will automatically be linked),
            or if a FilterStage was passed it will be returned
getAllFieldNames(self)
getAllFieldNames - Get a list of all the fields on this table
 
  @return list<str> - List of all fields on model
getModel(self)
getModel - Gets the model <DatabaseModel> associated with this Query.
 
    NOTE: Not all queries have the same meaning here.
      For example, a SelectInnerJoinQuery
        has no "model" set but a list of "models" ( @see #getModels ).
      On a SelectGenericJoinQuery this returns the "primary" model, while #getModels returns all models.
 
      @return <DatabaseModel/None> - The "primary" model associated with this query if applicable
getModels(self)
getModels - Gets a list of the models <DatabaseModel> associated with this Query.
 
    NOTE: The meaning of the query comes into play here.
      For example, an InsertQuery would return a list of [ self.getModel() ].
      A SelectGenericJoinQuery would return all the applicable models
 
      @return list<DatabaseModel> - A list of alll models associated with this query
getTableName(self)
getTableName - Get the name of the table associated with this model
 
  @return <str> - Table Name
getWhereClause(self, whereJoin='AND')
getWhereClause - Gets the "WHERE" portion (including the string 'WHERE'), including all stages and sub-stages
 
  @param whereJoin - If there are multiple top-level filter stages on this Query, this is how they should be related to eachother,
    via AND or OR.
 
    Generally, it makes more sense to just add a single filter stage at the top level, and append additional stages onto that.
 
 @return <str> - The WHERE clause, or empty string if no conditions are present
getWhereClauseParams(self, whereJoin='AND', paramPrefix='')
getWhereClauseParams - Gets the "WHERE" portion (including the string 'WHERE'), parameterized and the parameters
 
    @param whereJoin <WHERE_AND/WHERE_OR> - Either 'AND' or 'OR', what will join the various conditions in this clause
 
    @param paramPrefix <str> Default '' - If not empty string, paramPrefix + "_" will be prepended to all parameters
 
  @see getWhereClause

Data descriptors inherited from QueryBase:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class QueryBase(builtins.object)
    QueryBase - Base object for constructing a query.
 
    Should be extended and not used directly
 
  Methods defined here:
__init__(self, model, filterStages=None)
__init__ - Create a QueryBase object
 
    @param model <DatabaseModel> - The DatabaseModel to use for this query
 
    @param filterStages <None/list<FilterType objs>> Default None - 
    
        You may past a list of initial filter stages to use in the WHERE portion of the query, or leave as None and add them indivdiualy with #addStage (preferred).
 
        This list will be copied, but the stages themselves will not
          (so if you add a condition to one of these stages, that will carry over,
           but if you append to the list you provided here that will not.
           Use #addStage instead.
          )
addStage(self, _filter='AND')
addStage - Add a "stage" to the WHERE condition. A stage is a collection of conditional expressions.
 
  @param _filter:
    <str>  -  Default WHERE_AND - WHERE_AND or WHERE_OR , this specifies the relation of the various
             conditionals in this stage,
             i.e. if it should be ( conA AND conB AND conC )   or  ( conA OR conB OR conC )
 
    <FilterStage> - Adds a FilterStage directly
 
   @return - The FilterStage created by calling this method (just add to it, and it will automatically be linked),
            or if a FilterStage was passed it will be returned
execute(self, dbConn=None, doCommit=True)
execute - Perform the action of this query, regardless of type
            (useful for batching transactions into lists and iterating through)
 
          @param dbConn <DatabaseConnection/None> Default None -
                    The postgresql connection to use, or None to
                    create a new one from global settings.
 
                    Must be defined if doCommit=False (so you can commit later)
getAllFieldNames(self)
getAllFieldNames - Get a list of all the fields on this table
 
  @return list<str> - List of all fields on model
getModel(self)
getModel - Gets the model <DatabaseModel> associated with this Query.
 
    NOTE: Not all queries have the same meaning here.
      For example, a SelectInnerJoinQuery
        has no "model" set but a list of "models" ( @see #getModels ).
      On a SelectGenericJoinQuery this returns the "primary" model, while #getModels returns all models.
 
      @return <DatabaseModel/None> - The "primary" model associated with this query if applicable
getModels(self)
getModels - Gets a list of the models <DatabaseModel> associated with this Query.
 
    NOTE: The meaning of the query comes into play here.
      For example, an InsertQuery would return a list of [ self.getModel() ].
      A SelectGenericJoinQuery would return all the applicable models
 
      @return list<DatabaseModel> - A list of alll models associated with this query
getSql(self)
getSql - Get the SQL for this query
 
@return <str> - The SQL string
getTableName(self)
getTableName - Get the name of the table associated with this model
 
  @return <str> - Table Name
getWhereClause(self, whereJoin='AND')
getWhereClause - Gets the "WHERE" portion (including the string 'WHERE'), including all stages and sub-stages
 
  @param whereJoin - If there are multiple top-level filter stages on this Query, this is how they should be related to eachother,
    via AND or OR.
 
    Generally, it makes more sense to just add a single filter stage at the top level, and append additional stages onto that.
 
 @return <str> - The WHERE clause, or empty string if no conditions are present
getWhereClauseParams(self, whereJoin='AND', paramPrefix='')
getWhereClauseParams - Gets the "WHERE" portion (including the string 'WHERE'), parameterized and the parameters
 
    @param whereJoin <WHERE_AND/WHERE_OR> - Either 'AND' or 'OR', what will join the various conditions in this clause
 
    @param paramPrefix <str> Default '' - If not empty string, paramPrefix + "_" will be prepended to all parameters
 
  @see getWhereClause

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class QueryStr(builtins.str)
    QueryStr - A portion that should be treated like a raw string (Embedded sql),
  and not a quoted value
 
 
Method resolution order:
QueryStr
builtins.str
builtins.object

Methods defined here:
__eq__(self, other)
Return self==value.
__ne__(self, other)
Return self!=value.

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Data and other attributes defined here:
__hash__ = None

Methods inherited from builtins.str:
__add__(self, value, /)
Return self+value.
__contains__(self, key, /)
Return key in self.
__format__(...)
S.__format__(format_spec) -> str
 
Return a formatted version of S as described by format_spec.
__ge__(self, value, /)
Return self>=value.
__getattribute__(self, name, /)
Return getattr(self, name).
__getitem__(self, key, /)
Return self[key].
__getnewargs__(...)
__gt__(self, value, /)
Return self>value.
__iter__(self, /)
Implement iter(self).
__le__(self, value, /)
Return self<=value.
__len__(self, /)
Return len(self).
__lt__(self, value, /)
Return self<value.
__mod__(self, value, /)
Return self%value.
__mul__(self, value, /)
Return self*value.n
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
__repr__(self, /)
Return repr(self).
__rmod__(self, value, /)
Return value%self.
__rmul__(self, value, /)
Return self*value.
__sizeof__(...)
S.__sizeof__() -> size of S in memory, in bytes
__str__(self, /)
Return str(self).
capitalize(...)
S.capitalize() -> str
 
Return a capitalized version of S, i.e. make the first character
have upper case and the rest lower case.
casefold(...)
S.casefold() -> str
 
Return a version of S suitable for caseless comparisons.
center(...)
S.center(width[, fillchar]) -> str
 
Return S centered in a string of length width. Padding is
done using the specified fill character (default is a space)
count(...)
S.count(sub[, start[, end]]) -> int
 
Return the number of non-overlapping occurrences of substring sub in
string S[start:end].  Optional arguments start and end are
interpreted as in slice notation.
encode(...)
S.encode(encoding='utf-8', errors='strict') -> bytes
 
Encode S using the codec registered for encoding. Default encoding
is 'utf-8'. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
'xmlcharrefreplace' as well as any other name registered with
codecs.register_error that can handle UnicodeEncodeErrors.
endswith(...)
S.endswith(suffix[, start[, end]]) -> bool
 
Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
expandtabs(...)
S.expandtabs(tabsize=8) -> str
 
Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
find(...)
S.find(sub[, start[, end]]) -> int
 
Return the lowest index in S where substring sub is found,
such that sub is contained within S[start:end].  Optional
arguments start and end are interpreted as in slice notation.
 
Return -1 on failure.
format(...)
S.format(*args, **kwargs) -> str
 
Return a formatted version of S, using substitutions from args and kwargs.
The substitutions are identified by braces ('{' and '}').
format_map(...)
S.format_map(mapping) -> str
 
Return a formatted version of S, using substitutions from mapping.
The substitutions are identified by braces ('{' and '}').
index(...)
S.index(sub[, start[, end]]) -> int
 
Return the lowest index in S where substring sub is found, 
such that sub is contained within S[start:end].  Optional
arguments start and end are interpreted as in slice notation.
 
Raises ValueError when the substring is not found.
isalnum(...)
S.isalnum() -> bool
 
Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.
isalpha(...)
S.isalpha() -> bool
 
Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.
isdecimal(...)
S.isdecimal() -> bool
 
Return True if there are only decimal characters in S,
False otherwise.
isdigit(...)
S.isdigit() -> bool
 
Return True if all characters in S are digits
and there is at least one character in S, False otherwise.
isidentifier(...)
S.isidentifier() -> bool
 
Return True if S is a valid identifier according
to the language definition.
 
Use keyword.iskeyword() to test for reserved identifiers
such as "def" and "class".
islower(...)
S.islower() -> bool
 
Return True if all cased characters in S are lowercase and there is
at least one cased character in S, False otherwise.
isnumeric(...)
S.isnumeric() -> bool
 
Return True if there are only numeric characters in S,
False otherwise.
isprintable(...)
S.isprintable() -> bool
 
Return True if all characters in S are considered
printable in repr() or S is empty, False otherwise.
isspace(...)
S.isspace() -> bool
 
Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.
istitle(...)
S.istitle() -> bool
 
Return True if S is a titlecased string and there is at least one
character in S, i.e. upper- and titlecase characters may only
follow uncased characters and lowercase characters only cased ones.
Return False otherwise.
isupper(...)
S.isupper() -> bool
 
Return True if all cased characters in S are uppercase and there is
at least one cased character in S, False otherwise.
join(...)
S.join(iterable) -> str
 
Return a string which is the concatenation of the strings in the
iterable.  The separator between elements is S.
ljust(...)
S.ljust(width[, fillchar]) -> str
 
Return S left-justified in a Unicode string of length width. Padding is
done using the specified fill character (default is a space).
lower(...)
S.lower() -> str
 
Return a copy of the string S converted to lowercase.
lstrip(...)
S.lstrip([chars]) -> str
 
Return a copy of the string S with leading whitespace removed.
If chars is given and not None, remove characters in chars instead.
partition(...)
S.partition(sep) -> (head, sep, tail)
 
Search for the separator sep in S, and return the part before it,
the separator itself, and the part after it.  If the separator is not
found, return S and two empty strings.
replace(...)
S.replace(old, new[, count]) -> str
 
Return a copy of S with all occurrences of substring
old replaced by new.  If the optional argument count is
given, only the first count occurrences are replaced.
rfind(...)
S.rfind(sub[, start[, end]]) -> int
 
Return the highest index in S where substring sub is found,
such that sub is contained within S[start:end].  Optional
arguments start and end are interpreted as in slice notation.
 
Return -1 on failure.
rindex(...)
S.rindex(sub[, start[, end]]) -> int
 
Return the highest index in S where substring sub is found,
such that sub is contained within S[start:end].  Optional
arguments start and end are interpreted as in slice notation.
 
Raises ValueError when the substring is not found.
rjust(...)
S.rjust(width[, fillchar]) -> str
 
Return S right-justified in a string of length width. Padding is
done using the specified fill character (default is a space).
rpartition(...)
S.rpartition(sep) -> (head, sep, tail)
 
Search for the separator sep in S, starting at the end of S, and return
the part before it, the separator itself, and the part after it.  If the
separator is not found, return two empty strings and S.
rsplit(...)
S.rsplit(sep=None, maxsplit=-1) -> list of strings
 
Return a list of the words in S, using sep as the
delimiter string, starting at the end of the string and
working to the front.  If maxsplit is given, at most maxsplit
splits are done. If sep is not specified, any whitespace string
is a separator.
rstrip(...)
S.rstrip([chars]) -> str
 
Return a copy of the string S with trailing whitespace removed.
If chars is given and not None, remove characters in chars instead.
split(...)
S.split(sep=None, maxsplit=-1) -> list of strings
 
Return a list of the words in S, using sep as the
delimiter string.  If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are
removed from the result.
splitlines(...)
S.splitlines([keepends]) -> list of strings
 
Return a list of the lines in S, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.
startswith(...)
S.startswith(prefix[, start[, end]]) -> bool
 
Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.
strip(...)
S.strip([chars]) -> str
 
Return a copy of the string S with leading and trailing
whitespace removed.
If chars is given and not None, remove characters in chars instead.
swapcase(...)
S.swapcase() -> str
 
Return a copy of S with uppercase characters converted to lowercase
and vice versa.
title(...)
S.title() -> str
 
Return a titlecased version of S, i.e. words start with title case
characters, all remaining cased characters have lower case.
translate(...)
S.translate(table) -> str
 
Return a copy of the string S in which each character has been mapped
through the given translation table. The table must implement
lookup/indexing via __getitem__, for instance a dictionary or list,
mapping Unicode ordinals to Unicode ordinals, strings, or None. If
this operation raises LookupError, the character is left untouched.
Characters mapped to None are deleted.
upper(...)
S.upper() -> str
 
Return a copy of S converted to uppercase.
zfill(...)
S.zfill(width) -> str
 
Pad a numeric string S with zeros on the left, to fill a field
of the specified width. The string S is never truncated.

Static methods inherited from builtins.str:
maketrans(x, y=None, z=None, /)
Return a translation table usable for str.translate().
 
If there is only one argument, it must be a dictionary mapping Unicode
ordinals (integers) or characters to Unicode ordinals, strings or None.
Character keys will be then converted to ordinals.
If there are two arguments, they must be strings of equal length, and
in the resulting dictionary, each character in x will be mapped to the
character at the same position in y. If there is a third argument, it
must be a string, whose characters will be mapped to None in the result.

 
class SelectGenericJoinQuery(SelectQuery)
    SelectInnerJoinQuery - A SELECT query on multiple tables which supports inner join
 
 
Method resolution order:
SelectGenericJoinQuery
SelectQuery
QueryBase
builtins.object

Methods defined here:
__init__(self, primaryModel, selectFields='ALL', orderByField=None, orderByDir='', limitNum=None)
__init__ - Create a SelectGenericJoinQuery
 
    @param primaryModel - <DatabaseModel> - Primary Database model
 
    @param selectFields <'ALL' or list<str>> - Default ALL for all fields on all joined models, or a list of fields to select (prefix with table name, like MyTable.myField).
 
        Use MyModel.TABLE_NAME + '.*' to select all fields on "MyModel"
 
    @param orderByField <None/str> - Default None, if provided ORDER BY this field
 
    @param orderByDir <str> Default '', ASC or DESC for direction
 
    @param limitNum <None/int> default None - If provided, return max this many records
executeGetDictObjs(self, parameterized=True, dbConn=None)
executeGetDictObjs - Execute this query, and map results to DictObjs by table.
 
    I.e. if you have a table "MyTable" and a field "MyTable.MyField", you can access like:
 
        rows = executeGetDictObjs()
 
        result1 = rows[0]
 
        myTableMyField = result1.MyTable.MyField
 
    @param paramertized <bool> Default True - Whether to use parameterized query
 
    @param dbConn <DatabaseConnection/None> - If None, start a new connection using the
                                 global connection parameters.
                                 Otherwise, use this provided connection
 
 
    @return list<DictObjs> - List of rows, a DictObj for each row.
executeGetMapping(self, parameterized=True, dbConn=None)
executeGetMapping - Execute this query, and return the results as
    a list of rows, where each list contains a map (OrderedDict) of the field name -> value
 
    @param paramertized <bool> Default True - Whether to use parameterized query
 
    @param dbConn <DatabaseConnection/None> - If None, start a new connection using the
                                 global connection parameters.
                                 Otherwise, use this provided connection
 
@return list<dict> - List of rows, each row as a dict with named columns
executeGetObjs(self, parameterized=True, dbConn=None)
executeGetObjs - Not supported on SelectGenericJoinQuery
getAllFieldNames(self)
getAllFieldNames - Get a list of all field names on the primary table
 
    @return list<str> - TABLE_NAME.fieldName for each field
getAllFieldNamesByTable(self)
getAllFieldNamesByTable - Gets a dict of table name to list of all fields for that model
 
    @return dict table name<str> -> list<str> fields
getAllFieldNamesIncludingTable(self)
getAllFieldNamesIncludingTable - Get a list of all the field names prefixed with "$tableName."
 
    @return list<str> - List of all table names and fields
getFields(self)
getFields - Gets the fields to SELECT
 
    @return list<str> - List of field names
getJoinClauses(self)
getJoinClauses - Get a string of all the JOIN clauses with other tables
 
    @return <str> - Join clause
getJoinClausesParams(self, paramPrefix='')
getJoinClausesParams - Get the "join" clauses with paramertized parameters
 
    @param paramPrefix <str> Default '' - If not empty string, paramPrefix + "_" will be prepended to all parameters
getSql(self)
getSql - Gets the sql command to execute
getSqlParameterizedValues(self, paramPrefix='')
getSqlParameterizedValues - Get the SQL with parameterized values
 
    @param paramPrefix <str> Default '' - If provided, will prefix params with paramPrefix + "_"
 
    @return tuple( sql<str>, params<list<str>>)
getTableNames(self)
getTableNames - Get a list of all table names in this query
 
    @return list<str> - A list of table names
getTableNamesStr(self)
getTableNamesStr - Get a comma-joined string of table names in this query
 
    @return <str> - comma-joined string of table names
joinModel(self, model, joinType, conditionGrouping='AND')
joinModel - Join to another model, using a join type and given condition grouping
 
    @param model <DatabaseModel> - Database model to use
 
    @param joinType <str> - A join type (see JOIN_* in constants.py)
 
    @param conditionGrouping <str> default AND, either WHERE_AND or WHERE_OR
 
    @return - The stage that makes up the conditional on the join.

Methods inherited from SelectQuery:
addOrderBy(self, fieldName, orderByDir='')
addOrderBy - Add an additional "ORDER BY"
asQueryStr(self)
asQueryStr - Return this SELECT as an embedded group
        (for use in setting field values based on selected values and similar endeavours
 
      @return <QueryStr> -
                    A QueryStr representing this SELECT, with values inline
asQueryStrParams(self, paramPrefix='')
asQueryStrParams - Return this SELECT as an embedded group, paramertized version
        (for use in setting field values based on selected values and similar endeavours
 
      @param paramPrefix <str> - If provided, will prefix the parameters with this string + '_'
 
      @return tuple( <QueryStr>, <dict> ) - A tuple containing:
                    0 - A QueryStr representing this SELECT
                    1 - A dict containing any params (to be added to param list)
clearOrderBy(self)
clearOrderBy - Clears the "ORDER BY" portion of this query
execute(self, dbConn=None, doCommit=True)
execute - Execute this action, generic method.
 
        For SelectQuery, will call executeGetRows
 
    @param dbConn <DatabaseConnection/None> Default None - If None, start a new connection
            using the global connection settings. Otherwise, use given connection.
 
    @param doCommit <bool> Default True - Ignored on SelectQuery
executeGetRows(self, parameterized=True, dbConn=None)
executeGetRows - Execute and return the raw data from postgres in rows of columns
 
    @param paramertized <bool> Default True - Whether to use parameterized query
 
    @param dbConn <DatabaseConnection/None> - If None, start a new connection using the
                                 global connection parameters.
                                 Otherwise, use this provided connection
 
@return list<list<str>> - Rows of columns
getFieldsStr(self)
getFieldsStr - Get comma-separated names of fields fit for going into a query
getLimitStr(self)
getLimitStr - Get the LIMIT N portion of the query string
getOrderByStr(self)
getOrderByStr - Gets the ORDER BY portion (or empty string if unset) of the query
removeOrderBy(self, fieldName)
removeOrderBy - Remove the 'ORDER BY' for a given field
 
    @param  fieldName <str> - Name of field ordered by
 
    @return None or tuple ( fieldName<str>, orderByDirection<str> ) if found
setLimitNum(self, limitNum)
setLimitNum - Set the limit num (max # of records returned)
 
    @param limitNum <int/None> - Provide the maximum number of records to return, or None for no limit.
setSelectFields(self, selectFields)
setSelectFields - Set the fields to select
 
@param selectFields list<str> - Field names
toStr = asQueryStr(self)
asQueryStr - Return this SELECT as an embedded group
        (for use in setting field values based on selected values and similar endeavours
 
      @return <QueryStr> -
                    A QueryStr representing this SELECT, with values inline
toStrParam(self, prefix)

Methods inherited from QueryBase:
addStage(self, _filter='AND')
addStage - Add a "stage" to the WHERE condition. A stage is a collection of conditional expressions.
 
  @param _filter:
    <str>  -  Default WHERE_AND - WHERE_AND or WHERE_OR , this specifies the relation of the various
             conditionals in this stage,
             i.e. if it should be ( conA AND conB AND conC )   or  ( conA OR conB OR conC )
 
    <FilterStage> - Adds a FilterStage directly
 
   @return - The FilterStage created by calling this method (just add to it, and it will automatically be linked),
            or if a FilterStage was passed it will be returned
getModel(self)
getModel - Gets the model <DatabaseModel> associated with this Query.
 
    NOTE: Not all queries have the same meaning here.
      For example, a SelectInnerJoinQuery
        has no "model" set but a list of "models" ( @see #getModels ).
      On a SelectGenericJoinQuery this returns the "primary" model, while #getModels returns all models.
 
      @return <DatabaseModel/None> - The "primary" model associated with this query if applicable
getModels(self)
getModels - Gets a list of the models <DatabaseModel> associated with this Query.
 
    NOTE: The meaning of the query comes into play here.
      For example, an InsertQuery would return a list of [ self.getModel() ].
      A SelectGenericJoinQuery would return all the applicable models
 
      @return list<DatabaseModel> - A list of alll models associated with this query
getTableName(self)
getTableName - Get the name of the table associated with this model
 
  @return <str> - Table Name
getWhereClause(self, whereJoin='AND')
getWhereClause - Gets the "WHERE" portion (including the string 'WHERE'), including all stages and sub-stages
 
  @param whereJoin - If there are multiple top-level filter stages on this Query, this is how they should be related to eachother,
    via AND or OR.
 
    Generally, it makes more sense to just add a single filter stage at the top level, and append additional stages onto that.
 
 @return <str> - The WHERE clause, or empty string if no conditions are present
getWhereClauseParams(self, whereJoin='AND', paramPrefix='')
getWhereClauseParams - Gets the "WHERE" portion (including the string 'WHERE'), parameterized and the parameters
 
    @param whereJoin <WHERE_AND/WHERE_OR> - Either 'AND' or 'OR', what will join the various conditions in this clause
 
    @param paramPrefix <str> Default '' - If not empty string, paramPrefix + "_" will be prepended to all parameters
 
  @see getWhereClause

Data descriptors inherited from QueryBase:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class SelectInnerJoinQuery(SelectQuery)
    SelectInnerJoinQuery - A SELECT query on multiple tables which supports inner join
 
 
Method resolution order:
SelectInnerJoinQuery
SelectQuery
QueryBase
builtins.object

Methods defined here:
__init__(self, models, selectFields='ALL', orderByField=None, orderByDir='', limitNum=None)
__init__ - Create a SelectInnerJoinQuery
 
    @param models - list<DatabaseModel> - List of models to use
 
    @param selectFields <'ALL' or list<str>> - Default ALL for all fields on all joined models, or a list of fields to select (prefix with table name, like MyTable.myField)
        
 
        Use MyModel.TABLE_NAME + '.*' to select all fields on "MyModel"
 
    @param orderByField <None/str> Default None - Order by this field, if provided
 
    @param orderByDir <str> Default '' - ASC or DESC for ascneding/descending
 
    @param limitNum <int/None> default None - If provided, will return MAX this many results
executeGetDictObjs(self, parameterized=True, dbConn=None)
executeGetDictObjs - Execute this query, and map results to DictObjs by table.
 
    I.e. if you have a table "MyTable" and a field "MyTable.MyField", you can access like:
 
        rows = executeGetDictObjs()
 
        result1 = rows[0]
 
        myTableMyField = result1.MyTable.MyField
 
    @param paramertized <bool> Default True - Whether to use parameterized query
 
    @param dbConn <DatabaseConnection/None> - If None, start a new connection using the
                                 global connection parameters.
                                 Otherwise, use this provided connection
 
    @return list<DictObjs> - List of rows, a DictObj for each row.
executeGetMapping(self, parameterized=True, dbConn=None)
executeGetMapping - Execute this query, and return the results as
    a list of rows, where each list contains a map (OrderedDict) of the field name -> value
 
    @param paramertized <bool> Default True - Whether to use parameterized query
 
    @param dbConn <DatabaseConnection/None> - If None, start a new connection using the
                                 global connection parameters.
                                 Otherwise, use this provided connection
 
@return list<dict> - List of rows, each row as a dict with named columns
executeGetObjs(self, parameterized=True, dbConn=None)
executeGetObjs - Not supported for SelectInnerJoinQuery
getAllFieldNames(self)
getAllFieldNames - Not implemented on SelectInnerJoinQuery
getAllFieldNamesByTable(self)
getAllFieldNamesByTable - Get a map of table name : fields for all tables
 
    @return dict <str> : list<str> - Table name as key, all fields as value
getAllFieldNamesIncludingTable(self)
getAllFieldNamesIncludingTable - Get a list of all fields prefixed with table name,
 
    i.e.  tableName.fieldName for each table and all fields
 
    @return list<str> - List of tableName.fieldName for all tables and fields
getFields(self)
getFields - Get a string of the fields to use in SELECT
 
    @return list<str> - List of fields to select
getSql(self)
getSql - Gets the sql command to execute
getSqlParameterizedValues(self, paramPrefix='')
getSqlParameterizedValues - Gets the SQL command to execute using parameterized values
 
    @param paramPrefix <str> Default '' - If provided, will prefix params with paramPrefix + "_"
 
    @return tuple ( sql<str>, whereParams list<str> )
getTableName(self)
getTableName - Not implemented on SelectInnerJoinQuery
getTableNames(self)
getTableNames - Get a list of associated table names
 
    @return list<str> - List of table names
getTableNamesStr(self)
getTableNamesStr - Get a comma-joined string of associated table names
 
    @return <str> - comma-joined string of associated table names

Methods inherited from SelectQuery:
addOrderBy(self, fieldName, orderByDir='')
addOrderBy - Add an additional "ORDER BY"
asQueryStr(self)
asQueryStr - Return this SELECT as an embedded group
        (for use in setting field values based on selected values and similar endeavours
 
      @return <QueryStr> -
                    A QueryStr representing this SELECT, with values inline
asQueryStrParams(self, paramPrefix='')
asQueryStrParams - Return this SELECT as an embedded group, paramertized version
        (for use in setting field values based on selected values and similar endeavours
 
      @param paramPrefix <str> - If provided, will prefix the parameters with this string + '_'
 
      @return tuple( <QueryStr>, <dict> ) - A tuple containing:
                    0 - A QueryStr representing this SELECT
                    1 - A dict containing any params (to be added to param list)
clearOrderBy(self)
clearOrderBy - Clears the "ORDER BY" portion of this query
execute(self, dbConn=None, doCommit=True)
execute - Execute this action, generic method.
 
        For SelectQuery, will call executeGetRows
 
    @param dbConn <DatabaseConnection/None> Default None - If None, start a new connection
            using the global connection settings. Otherwise, use given connection.
 
    @param doCommit <bool> Default True - Ignored on SelectQuery
executeGetRows(self, parameterized=True, dbConn=None)
executeGetRows - Execute and return the raw data from postgres in rows of columns
 
    @param paramertized <bool> Default True - Whether to use parameterized query
 
    @param dbConn <DatabaseConnection/None> - If None, start a new connection using the
                                 global connection parameters.
                                 Otherwise, use this provided connection
 
@return list<list<str>> - Rows of columns
getFieldsStr(self)
getFieldsStr - Get comma-separated names of fields fit for going into a query
getLimitStr(self)
getLimitStr - Get the LIMIT N portion of the query string
getOrderByStr(self)
getOrderByStr - Gets the ORDER BY portion (or empty string if unset) of the query
removeOrderBy(self, fieldName)
removeOrderBy - Remove the 'ORDER BY' for a given field
 
    @param  fieldName <str> - Name of field ordered by
 
    @return None or tuple ( fieldName<str>, orderByDirection<str> ) if found
setLimitNum(self, limitNum)
setLimitNum - Set the limit num (max # of records returned)
 
    @param limitNum <int/None> - Provide the maximum number of records to return, or None for no limit.
setSelectFields(self, selectFields)
setSelectFields - Set the fields to select
 
@param selectFields list<str> - Field names
toStr = asQueryStr(self)
asQueryStr - Return this SELECT as an embedded group
        (for use in setting field values based on selected values and similar endeavours
 
      @return <QueryStr> -
                    A QueryStr representing this SELECT, with values inline
toStrParam(self, prefix)

Methods inherited from QueryBase:
addStage(self, _filter='AND')
addStage - Add a "stage" to the WHERE condition. A stage is a collection of conditional expressions.
 
  @param _filter:
    <str>  -  Default WHERE_AND - WHERE_AND or WHERE_OR , this specifies the relation of the various
             conditionals in this stage,
             i.e. if it should be ( conA AND conB AND conC )   or  ( conA OR conB OR conC )
 
    <FilterStage> - Adds a FilterStage directly
 
   @return - The FilterStage created by calling this method (just add to it, and it will automatically be linked),
            or if a FilterStage was passed it will be returned
getModel(self)
getModel - Gets the model <DatabaseModel> associated with this Query.
 
    NOTE: Not all queries have the same meaning here.
      For example, a SelectInnerJoinQuery
        has no "model" set but a list of "models" ( @see #getModels ).
      On a SelectGenericJoinQuery this returns the "primary" model, while #getModels returns all models.
 
      @return <DatabaseModel/None> - The "primary" model associated with this query if applicable
getModels(self)
getModels - Gets a list of the models <DatabaseModel> associated with this Query.
 
    NOTE: The meaning of the query comes into play here.
      For example, an InsertQuery would return a list of [ self.getModel() ].
      A SelectGenericJoinQuery would return all the applicable models
 
      @return list<DatabaseModel> - A list of alll models associated with this query
getWhereClause(self, whereJoin='AND')
getWhereClause - Gets the "WHERE" portion (including the string 'WHERE'), including all stages and sub-stages
 
  @param whereJoin - If there are multiple top-level filter stages on this Query, this is how they should be related to eachother,
    via AND or OR.
 
    Generally, it makes more sense to just add a single filter stage at the top level, and append additional stages onto that.
 
 @return <str> - The WHERE clause, or empty string if no conditions are present
getWhereClauseParams(self, whereJoin='AND', paramPrefix='')
getWhereClauseParams - Gets the "WHERE" portion (including the string 'WHERE'), parameterized and the parameters
 
    @param whereJoin <WHERE_AND/WHERE_OR> - Either 'AND' or 'OR', what will join the various conditions in this clause
 
    @param paramPrefix <str> Default '' - If not empty string, paramPrefix + "_" will be prepended to all parameters
 
  @see getWhereClause

Data descriptors inherited from QueryBase:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class SelectQuery(QueryBase)
    SelectQuery - A Query designed for "SELECT".
 
 
Method resolution order:
SelectQuery
QueryBase
builtins.object

Methods defined here:
__init__(self, model, selectFields='ALL', filterStages=None, orderByField=None, orderByDir='', limitNum=None)
__init__ - Create a SelectQuery
 
    @param model <DatabaseModel> - The model associated with this query
 
    @param selectFields <list/'ALL'> Defalult 'ALL' - The fields to select. Default 'ALL' will return all fields on this model
 
    @param filterStages list<FilterStage> - A list of initial filter stages (can and should just be added later)
 
            TODO: Refactor and remove "filterStages" from constructor. I thought maybe for copying it would be useful,
                but forget it.
 
    @param orderByField - If provided, the first "orderBy" for this query. Can be appended to or removed later. Should be a field name.
    @param orderByDir <str> - If provided, the direction the "order by" will follow.
 
    @param limitNum <None/int> default None, if provided integer, will return no more than N rows
addOrderBy(self, fieldName, orderByDir='')
addOrderBy - Add an additional "ORDER BY"
asQueryStr(self)
asQueryStr - Return this SELECT as an embedded group
        (for use in setting field values based on selected values and similar endeavours
 
      @return <QueryStr> -
                    A QueryStr representing this SELECT, with values inline
asQueryStrParams(self, paramPrefix='')
asQueryStrParams - Return this SELECT as an embedded group, paramertized version
        (for use in setting field values based on selected values and similar endeavours
 
      @param paramPrefix <str> - If provided, will prefix the parameters with this string + '_'
 
      @return tuple( <QueryStr>, <dict> ) - A tuple containing:
                    0 - A QueryStr representing this SELECT
                    1 - A dict containing any params (to be added to param list)
clearOrderBy(self)
clearOrderBy - Clears the "ORDER BY" portion of this query
execute(self, dbConn=None, doCommit=True)
execute - Execute this action, generic method.
 
        For SelectQuery, will call executeGetRows
 
    @param dbConn <DatabaseConnection/None> Default None - If None, start a new connection
            using the global connection settings. Otherwise, use given connection.
 
    @param doCommit <bool> Default True - Ignored on SelectQuery
executeGetObjs(self, parameterized=True, dbConn=None)
executeGetObjs - Execute and transform the returned data into a series of objects, one per row returned.
 
    @param paramertized <bool> Default True - Whether to use parameterized query
 
    @param dbConn <DatabaseConnection/None> - If None, start a new connection using the
                                 global connection parameters.
                                 Otherwise, use this provided connection
 
@return list<model object> - A list of constructed model objects with the fields from this query filled
executeGetRows(self, parameterized=True, dbConn=None)
executeGetRows - Execute and return the raw data from postgres in rows of columns
 
    @param paramertized <bool> Default True - Whether to use parameterized query
 
    @param dbConn <DatabaseConnection/None> - If None, start a new connection using the
                                 global connection parameters.
                                 Otherwise, use this provided connection
 
@return list<list<str>> - Rows of columns
getFields(self)
getFields - Get a list of the fields to select (will unroll the special, "ALL")
getFieldsStr(self)
getFieldsStr - Get comma-separated names of fields fit for going into a query
getLimitStr(self)
getLimitStr - Get the LIMIT N portion of the query string
getOrderByStr(self)
getOrderByStr - Gets the ORDER BY portion (or empty string if unset) of the query
getSql(self)
getSql - Gets the sql command to execute
getSqlParameterizedValues(self, paramPrefix='')
getSqlParameterizedValues - Get the sql command parameterized
 
    @param paramPrefix <str> Default '' - If provided, will prefix params with paramPrefix + "_"
 
    @return tuple< sql<str>, whereParams <list<FilterStage obj>> >
removeOrderBy(self, fieldName)
removeOrderBy - Remove the 'ORDER BY' for a given field
 
    @param  fieldName <str> - Name of field ordered by
 
    @return None or tuple ( fieldName<str>, orderByDirection<str> ) if found
setLimitNum(self, limitNum)
setLimitNum - Set the limit num (max # of records returned)
 
    @param limitNum <int/None> - Provide the maximum number of records to return, or None for no limit.
setSelectFields(self, selectFields)
setSelectFields - Set the fields to select
 
@param selectFields list<str> - Field names
toStr = asQueryStr(self)
toStrParam(self, prefix)

Methods inherited from QueryBase:
addStage(self, _filter='AND')
addStage - Add a "stage" to the WHERE condition. A stage is a collection of conditional expressions.
 
  @param _filter:
    <str>  -  Default WHERE_AND - WHERE_AND or WHERE_OR , this specifies the relation of the various
             conditionals in this stage,
             i.e. if it should be ( conA AND conB AND conC )   or  ( conA OR conB OR conC )
 
    <FilterStage> - Adds a FilterStage directly
 
   @return - The FilterStage created by calling this method (just add to it, and it will automatically be linked),
            or if a FilterStage was passed it will be returned
getAllFieldNames(self)
getAllFieldNames - Get a list of all the fields on this table
 
  @return list<str> - List of all fields on model
getModel(self)
getModel - Gets the model <DatabaseModel> associated with this Query.
 
    NOTE: Not all queries have the same meaning here.
      For example, a SelectInnerJoinQuery
        has no "model" set but a list of "models" ( @see #getModels ).
      On a SelectGenericJoinQuery this returns the "primary" model, while #getModels returns all models.
 
      @return <DatabaseModel/None> - The "primary" model associated with this query if applicable
getModels(self)
getModels - Gets a list of the models <DatabaseModel> associated with this Query.
 
    NOTE: The meaning of the query comes into play here.
      For example, an InsertQuery would return a list of [ self.getModel() ].
      A SelectGenericJoinQuery would return all the applicable models
 
      @return list<DatabaseModel> - A list of alll models associated with this query
getTableName(self)
getTableName - Get the name of the table associated with this model
 
  @return <str> - Table Name
getWhereClause(self, whereJoin='AND')
getWhereClause - Gets the "WHERE" portion (including the string 'WHERE'), including all stages and sub-stages
 
  @param whereJoin - If there are multiple top-level filter stages on this Query, this is how they should be related to eachother,
    via AND or OR.
 
    Generally, it makes more sense to just add a single filter stage at the top level, and append additional stages onto that.
 
 @return <str> - The WHERE clause, or empty string if no conditions are present
getWhereClauseParams(self, whereJoin='AND', paramPrefix='')
getWhereClauseParams - Gets the "WHERE" portion (including the string 'WHERE'), parameterized and the parameters
 
    @param whereJoin <WHERE_AND/WHERE_OR> - Either 'AND' or 'OR', what will join the various conditions in this clause
 
    @param paramPrefix <str> Default '' - If not empty string, paramPrefix + "_" will be prepended to all parameters
 
  @see getWhereClause

Data descriptors inherited from QueryBase:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class UpdateQuery(QueryBase)
    UpdateQuery - Perform an update on a model
 
 
Method resolution order:
UpdateQuery
QueryBase
builtins.object

Methods defined here:
__init__(self, model, newFieldValues=None, filterStages=None)
__init__ - Create an update query
 
  @param model - The model class
 
  @param newFieldValues <dict/None> Default None.
 
        If provided, will use these as initial field values for update.
        Providing this is the same as calling #setFieldValues(newFieldValues)
 
        You can set the value of specific fields using either the #setFieldValue or #setFieldValues
            methods after constructing the object.
 
  @param filterStages <None/list<FilterStage>> Default None - Provide a list of
        
        filter stages to use. A copy of this list will be made internally
execute(self, dbConn=None, doCommit=True)
execute - Execute this action, generic method.
 
        For SelectQuery, will call executeUpdate
 
    @param dbConn <DatabaseConnection/None> Default None - If None, start a new connection
            using the global connection settings. Otherwise, use given connection.
 
    @param doCommit <bool> Default True - If True, will commit right away. If False, you must commit.
 
        A #dbConn must be specified if doCommit=False
executeUpdate(self, dbConn=None, doCommit=True)
executeUpdate - Upate records (parameterized)
 
    May potentially use an existing DatabaseConnection (for transaction)
 
@param dbConn <None/DatabaseConnection> - If None, will use a fresh connection and auto-commit.
   Otherwise, will use the provided connection (which may be linked to a transaction
 
@param doCommit <bool> default True - Whether to commit immediately
executeUpdateRawValues(self, dbConn=None, doCommit=False)
executeUpdate - Update some records
 
  @param dbConn <None/DatabaseConnection> - If None, will get a new connection with autocmommit.
 
  @param doCommit <bool> Default True - If True, will commit right away. If False, you must commit.
 
    Nay be passed a transaction-connection, to do update within a transaction
getSetFieldParamsAndValues(self)
getSetFieldParamsAndValues - For parameterized values,
 
    This returns a tuple of two values, the first is the paramertized marker to be used in the query,
      the second is a list of values which should be passed alongside
getSetFieldsStr(self)
getSetFieldsStr - Get the  X = "VALUE" , Y = "OTHER" portion of the SQL query
getSql(self)
getSql - Get sql command to execute
getSqlParameterizedValues(self, paramPrefix='')
getSqlParameterizedValues - Get the SQL to execute, parameterized version
 
  @param paramPrefix <str> Default '' - If provided, will prefix params with paramPrefix + "_"
setFieldValue(self, fieldName, newValue)
setFieldValue - Update a field to a new value
 
    @param fieldName <str> - The field name (should be in FIELDS array on model class)
 
    @param newValue <???> - The new value for the field. This can be a string, integer, datetime object, etc. 
          depending on the schema for this field
setFieldValues(self, fieldNameToValueMap)
setFieldValues - Sets one or more field -> value associations for the insert operation.
    
    "Bulk mode"
 
    @param fieldNameToValueMap dict<str : ???> - A map of field name -> field value

Data descriptors defined here:
hasAnyUpdates
hasAnyUpdates - Property reflecting whether any fields have been set thus far
    
    in this update query.
 
    @return <bool> - True if any fields have been configured to be updated, otherwise False

Methods inherited from QueryBase:
addStage(self, _filter='AND')
addStage - Add a "stage" to the WHERE condition. A stage is a collection of conditional expressions.
 
  @param _filter:
    <str>  -  Default WHERE_AND - WHERE_AND or WHERE_OR , this specifies the relation of the various
             conditionals in this stage,
             i.e. if it should be ( conA AND conB AND conC )   or  ( conA OR conB OR conC )
 
    <FilterStage> - Adds a FilterStage directly
 
   @return - The FilterStage created by calling this method (just add to it, and it will automatically be linked),
            or if a FilterStage was passed it will be returned
getAllFieldNames(self)
getAllFieldNames - Get a list of all the fields on this table
 
  @return list<str> - List of all fields on model
getModel(self)
getModel - Gets the model <DatabaseModel> associated with this Query.
 
    NOTE: Not all queries have the same meaning here.
      For example, a SelectInnerJoinQuery
        has no "model" set but a list of "models" ( @see #getModels ).
      On a SelectGenericJoinQuery this returns the "primary" model, while #getModels returns all models.
 
      @return <DatabaseModel/None> - The "primary" model associated with this query if applicable
getModels(self)
getModels - Gets a list of the models <DatabaseModel> associated with this Query.
 
    NOTE: The meaning of the query comes into play here.
      For example, an InsertQuery would return a list of [ self.getModel() ].
      A SelectGenericJoinQuery would return all the applicable models
 
      @return list<DatabaseModel> - A list of alll models associated with this query
getTableName(self)
getTableName - Get the name of the table associated with this model
 
  @return <str> - Table Name
getWhereClause(self, whereJoin='AND')
getWhereClause - Gets the "WHERE" portion (including the string 'WHERE'), including all stages and sub-stages
 
  @param whereJoin - If there are multiple top-level filter stages on this Query, this is how they should be related to eachother,
    via AND or OR.
 
    Generally, it makes more sense to just add a single filter stage at the top level, and append additional stages onto that.
 
 @return <str> - The WHERE clause, or empty string if no conditions are present
getWhereClauseParams(self, whereJoin='AND', paramPrefix='')
getWhereClauseParams - Gets the "WHERE" portion (including the string 'WHERE'), parameterized and the parameters
 
    @param whereJoin <WHERE_AND/WHERE_OR> - Either 'AND' or 'OR', what will join the various conditions in this clause
 
    @param paramPrefix <str> Default '' - If not empty string, paramPrefix + "_" will be prepended to all parameters
 
  @see getWhereClause

Data descriptors inherited from QueryBase:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
Functions
       
isFilterType(obj)
isFilterType - Check if this is a filterable type (on a field, or a collection thereof)
isSelectQuery(obj)
isSelectQuery - Checks if passed object inherits from SelectQuery

 
Data
        SQL_NULL = 'NULL'
__all__ = ('QueryStr', 'QueryBase', 'FilterType', 'isFilterType', 'FilterField', 'FilterJoin', 'FilterStage', 'isSelectQuery', 'SelectQuery', 'SelectInnerJoinQuery', 'SelectGenericJoinQuery', 'UpdateQuery', 'InsertQuery', 'DeleteQuery', 'SQL_NULL')