def __init__(self, column_name): column = ColumnClause(column_name) super(FilenameConstraint, self).__init__( and_( column.op("~")(literal_column("'^[A-Za-z0-9_.%-]+$'")), column != literal_column("'.'"), column != literal_column("'..'")))
def add_join(self, child_table, parent_column_name, child_column_name, is_outer=False): parent_column = ColumnClause(parent_column_name) child_column = ColumnClause(child_column_name) condition = (parent_column == child_column) self.joins.append((child_table, condition, is_outer))
def __init__(self, columns, param, bool=False, *args, **kwargs): if isinstance(columns, list): columns = ', '.join(str(c) for c in columns) if isinstance(param, basestring): param = sql.bindparam(param) bool_mode = bool and ' IN BOOLEAN MODE' or '' self.text = 'MATCH (%s) AGAINST (%s%s)' % (columns, param, bool_mode) self.bindparams[param.key] = param _ColumnClause.__init__(self, self.text, *args, **kwargs)
def __init__(self, Session, table, select, **kw): self.table = table self.select = select self.parent = None self.child = None self._bind = Session.bind self._whereclause = select._whereclause self.fk_type = None self.reverse = kw.pop('reverse', False) # we need to find the relation within the same table for ev in self.table.foreign_keys: if ev.column.table.name == ev.parent.table.name: if not self.reverse: self.parent = ev.parent.name self.child = ev.column.name else: self.parent = ev.column.name self.child = ev.parent.name break if self.parent is None or self.child is None: raise MissingForeignKeyError(self.table.name) self.starting_node = kw.pop('starting_node', None) self.ordering_colname = kw.pop('ordering_colname', 'ordering') # if starting node does not exist or it's null, we add starting_node=0 # by default if not hasattr(self, 'starting_node') or self.starting_node is None: self.fk_type = self.table.columns.get(self.parent).type._type_affinity # sqlalchemy cast "0" as 0 (I don't know how to fix it) so you will # get errors if the parent-child relation is not an integer. We # identify this situation and use "a" for comparison if self.fk_type == String: setattr(self, 'starting_node', "a") self.type_length = self.table.columns.get(self.parent).type.length else: setattr(self, 'starting_node', "0") elif self.starting_node is False: pass else: # we need to be sure the starting_node value is an String, # otherwise we might get an error self.starting_node = str(self.starting_node) columns = select.columns + [ ColumnClause('level', type_=Integer()), ColumnClause('connect_path', type_=ARRAY(self.fk_type)), ColumnClause('is_leaf', type_=Boolean()) ] if self.ordering_colname in select.columns: columns.append(ColumnClause('%s_path' % self.ordering_colname, type_=ARRAY(select.c[self.ordering_colname].type))) Select.__init__(self, columns, **kw)
def _build_table_clause(select, name, path_type): """For pgsql, it builds the recursive table needed to perform a hierarchical query. Parameters: * select instruction of type sqlalchemy.sql.expression.Select * a name for the new virtual table * the type for the connect_path column It returns a TableClause object """ cols = [] for ev in select.columns.keys(): cols.append(ColumnClause(ev, type_=getattr(select.columns, ev).type)) cols.append(ColumnClause('level', Integer)) cols.append(ColumnClause('connect_path', ARRAY(path_type))) tb = TableClause(name, *cols) return tb
def __init__(self, column_name): column = ColumnClause(column_name) # Postgres allows the condition "<sth> <op> ALL (<array>)" that # is true iff for all elements of array "<sth> <op> <element>". # This works for (in)equality but, as the order of the operands # is preserved, it doesn't work for regexp matching, where the # syntax is "<text> ~ <pattern>". Our regexp operates on a per # character basis so we can work around it by concatenating the # items of the array (using array_to_string) and match the # regexp on the result. empty = literal_column("''") super(FilenameListConstraint, self).__init__( and_( func.array_to_string(column, empty).op("~")( literal_column("'^[A-Za-z0-9_.%-]*$'")), empty != all_(column), literal_column("'.'") != all_(column), literal_column("'..'") != all_(column)))
def __init__(self, column_name): column = ColumnClause(column_name) super(DigestConstraint, self).__init__( column.op("~")(literal_column("'^([0-9a-f]{40}|%s)$'" % FileCacher.TOMBSTONE_DIGEST)))
def __init__(self, column_name): column = ColumnClause(column_name) super(CodenameConstraint, self).__init__( column.op("~")(literal_column("'^[A-Za-z0-9_-]+$'")))
def __init__(self, column): self.column = column ColumnClause.__init__(self, column.name, column.table)
def __init__(self, column_name): column = ColumnClause(column_name) super(DigestConstraint, self).__init__( column.op("~")(literal_column( "'^([0-9a-f]{40}|%s)$'" % FileCacher.TOMBSTONE_DIGEST)))
def __init__(self, column_name): column = ColumnClause(column_name) super(FilenameConstraint, self).__init__(and_( column.op("~")(literal_column("'^[A-Za-z0-9_.%-]+$'")), column != literal_column("'.'"), column != literal_column("'..'")))