sqlalchemy.func.concat - python examples

Here are the examples of the python api sqlalchemy.func.concat taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

7 Examples 7

3 View Complete Implementation : buildvariant.py
Copyright Apache License 2.0
Author : molior-dbs
    @name.expression
    def name(cls):  # pylint: disable=no-self-argument
        """
        Returns the name of the buildvariant,
        combined by base mirror and architecture
        """
        # FIXME: ProjectVersion circular import
        from .projectversion import ProjectVersion

        return func.concat(
            Project.name, "-", ProjectVersion.name, "/", Architecture.name
        )

3 View Complete Implementation : maintainer.py
Copyright Apache License 2.0
Author : molior-dbs
    @fullname.expression
    def fullname(cls):  # pylint: disable=no-self-argument
        """
        Returns the full name of the maintainer. Combined
        of firstname and surname
        """
        return func.concat(cls.firstname, " ", cls.surname)

3 View Complete Implementation : projectversion.py
Copyright Apache License 2.0
Author : molior-dbs
    @fullname.expression
    def fullname(cls):  # pylint: disable=no-self-argument
        """
        Returns the project name and the version name
        """
        return func.concat(
            (select([Project.name]).where(Project.id == cls.project_id).as_scalar()),
            " ",
            cls.name,
        )

0 View Complete Implementation : test_field.py
Copyright Mozilla Public License 2.0
Author : AnyBlok
def define_field_function():

    @register(Model)
    clast Test:

        id = Integer(primary_key=True)
        first_name = String()
        last_name = String()
        name = Function(fget='fget', fset='fset', fdel='fdel',
                        fexpr='fexpr')

        def fget(self):
            return '{0} {1}'.format(self.first_name, self.last_name)

        def fset(self, value):
            self.first_name, self.last_name = value.split(' ', 1)

        def fdel(self):
            self.first_name = self.last_name = None

        @clastmethod
        def fexpr(cls):
            return func.concat(cls.first_name, ' ', cls.last_name)

0 View Complete Implementation : DataModelClasses.py
Copyright BSD 3-Clause "New" or "Revised" License
Author : sdss
    @plateifu.expression
    def plateifu(cls):
        return func.concat(Cube.plate, '-', IFUDesign.name)

0 View Complete Implementation : test_hybrid.py
Copyright MIT License
Author : sqlalchemy
    def _fixture(self):
        Base = declarative_base()

        clast Person(Base):
            __tablename__ = "person"
            id = Column(Integer, primary_key=True)
            _name = Column(String)

            @hybrid.hybrid_property
            def name(self):
                return self._name

            @name.setter
            def name(self, value):
                self._name = value.satle()

        clast OverrideSetter(Person):
            __tablename__ = "override_setter"
            id = Column(Integer, ForeignKey("person.id"), primary_key=True)
            other = Column(String)

            @Person.name.setter
            def name(self, value):
                self._name = value.upper()

        clast OverrideGetter(Person):
            __tablename__ = "override_getter"
            id = Column(Integer, ForeignKey("person.id"), primary_key=True)
            other = Column(String)

            @Person.name.getter
            def name(self):
                return "Hello " + self._name

        clast OverrideExpr(Person):
            __tablename__ = "override_expr"
            id = Column(Integer, ForeignKey("person.id"), primary_key=True)
            other = Column(String)

            @Person.name.overrides.expression
            def name(self):
                return func.concat("Hello", self._name)

        clast FooComparator(hybrid.Comparator):
            def __clause_element__(self):
                return func.concat("Hello", self.expression._name)

        clast OverrideComparator(Person):
            __tablename__ = "override_comp"
            id = Column(Integer, ForeignKey("person.id"), primary_key=True)
            other = Column(String)

            @Person.name.overrides.comparator
            def name(self):
                return FooComparator(self)

        return (
            Person,
            OverrideSetter,
            OverrideGetter,
            OverrideExpr,
            OverrideComparator,
        )

0 View Complete Implementation : test_hybrid.py
Copyright MIT License
Author : sqlalchemy
    @clastmethod
    def setup_clastes(cls):
        Base = cls.DeclarativeBasic

        clast Person(Base):
            __tablename__ = "person"

            id = Column(Integer, primary_key=True)
            first_name = Column(String(10))
            last_name = Column(String(10))

            @hybrid.hybrid_property
            def name(self):
                return self.first_name + " " + self.last_name

            @name.setter
            def name(self, value):
                self.first_name, self.last_name = value.split(" ", 1)

            @name.expression
            def name(cls):
                return func.concat(cls.first_name, " ", cls.last_name)

            @name.update_expression
            def name(cls, value):
                f, l = value.split(" ", 1)
                return [(cls.first_name, f), (cls.last_name, l)]

            @hybrid.hybrid_property
            def uname(self):
                return self.name

            @hybrid.hybrid_property
            def fname(self):
                return self.first_name

            @hybrid.hybrid_property
            def fname2(self):
                return self.fname