Just negate the filter:

    MyModel.query.filter(sqlalchemy.not_(Mymodel.name.contains(&#39;a_string&#39;)))


There is now a ```notlike()``` method. Couldn&#39;t find it in the docs but it exists!
```
MyModel.query.filter(Mymodel.name.notlike(&#39;%a_string%&#39;))
```

I use C-style casts in my 15K LOC C++ project, 90% of the times for casts between child and base classes.

Even when I read that it is bad to use them, and that they can result in severe errors, as they are not type safe as the C++ casts, I still *feel* perfectly fine and comfortable with using them.

I have not experienced a single bug in my project so far that was caused by, for example, an accidentally mistyped C-Style cast - really.

There are two main reasons I have not been using them:

- I didn&#39;t know enough about them yet
- I didn&#39;t like their syntax, they are more verbose and harder to read for me

My questions:

- (Why) Should I refactor my project to use C++-style casts?
- Why should I use C++-style casts for my future projects?


I use as good as all other advantages C++ offers me, from OOP including virtual and abstract base classes, namespaces, the STL, and so on, just not the new type casting syntax.  The argument &quot;*Why aren&#39;t you just using C then?*&quot; doesn&#39;t work for me.

If I use C-Style casts in my C++ project, is it worth refactoring to C++ casts?

I have the following 2 functions:

    public static string Serialize(object obj)
    {
        DataContractSerializer serializer = new DataContractSerializer(obj.GetType());
        MemoryStream memoryStream = new MemoryStream();
        serializer.WriteObject(memoryStream, obj);
        return Encoding.UTF8.GetString(memoryStream.GetBuffer());
    }

    public static object Deserialize(string xml, Type toType)
    {
        MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(xml));
       // memoryStream.Position = 0L;
        XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(memoryStream, Encoding.UTF8, new XmlDictionaryReaderQuotas(), null);
        DataContractSerializer dataContractSerializer = new DataContractSerializer(toType);
        return dataContractSerializer.ReadObject(reader);
    }

The first one seems to serialize an object to an xml string just fine.  The XML appears valid, no broken tags, no white spaces at the beginning or at the end, etc.  Now the second function doesn&#39;t want to deserialize my xml string back to the object.  On the last line I get:

&gt; There was an error deserializing the
&gt; object of type [MY OBJECT TYPE HERE].
&gt; The data at the root level is invalid.
&gt; Line 1, position 1.

What am I doing wrong?  I tried rewriting the Deserialize function a few times, and it always seems to be the same kind of error.  Thank you!

Oh, and this is how I&#39;m calling the 2 functions:

    SomeObject so = new SomeObject();
    string temp = SerializationManager.Serialize(so);
    so = (SomeObject)SerializationManager.Deserialize(temp, typeof(SomeObject));



Using DataContractSerializer to serialize, but can&#39;t deserialize back

I&#39;ve got a query:  

    MyModel.query.filter(Mymodel.name.contains(&#39;a_string&#39;))

I need to do the same query but with the negation (a **not like** operator) but didn&#39;t find any operator matching my need in the &lt;a href=&quot;http://www.sqlalchemy.org/docs/orm/tutorial.html#common-filter-operators&quot;&gt;SQLAlchemy documentation&lt;/a&gt;.

Is there any way to do it without using the sql part of SQLAlchemy???


how to pass a not like operator in a sqlalchemy ORM query

I've got a query:
<pre><code class="hljs language-python">MyModel.query.filter(Mymodel.name.contains('a_string'))
</code></pre>
I need to do the same query but with the negation (a not like operator) but didn't find any operator matching my need in the <a href="<a href=" http:="" www.sqlalchemy.org="" docs="" orm="" tutorial.html#common-filter-operators&#x26;quot;&#x26;gt;sqlalchemy&#x22;="">http://www.sqlalchemy.org/docs/orm/tutorial.html#common-filter-operators">SQLAlchemy</a> documentation.
Is there any way to do it without using the sql part of SQLAlchemy???

I was talking with someone about the Entity Framework, and I&#39;m not really into it yet, but I&#39;d like to learn it. However, I&#39;m still kinda confused whether I should learn it or not. I&#39;ve heard a lot of people saying you shouldn&#39;t use the entity framwork, however I haven&#39;t heared any arguments why that is.

So my question is, what are the pro&#39;s and con&#39;s of using the Entity Framework [compared to other products][1]. Like

 - NHibernate
 - DataObjects.Net
 - etc..

In terms of ease of use, testability, semantics...


I know there are some [duplicate][2] [questions][3] about this. But they are all kinda outdated (2008,2009) and to be honest, the arguments are also lacking something. I know Entity Framework 4.0 is available, and I haven&#39;t found a good (complete) comparison yet. 

---
# Answers #
Some of the nice people here have answered my question by explaining some details on the different frameworks. Thought it might be good to show them here for future reference. 

 - [J. Tihon has made an excelent post explaining how to make the EF work when you need more extensibility.][4] 
 - [Diego Mijelshon has created an answer with some of the pitfalls of EF and how NHibernate solves them.][5] 


  [1]: https://stackoverflow.com/questions/1841555/what-are-some-good-entity-framework-alternatives
  [2]: https://stackoverflow.com/questions/662231/entity-framework-vs-alternatives
  [3]: https://stackoverflow.com/questions/3505/what-are-your-favorite-net-object-relational-mappers-orm
  [4]: https://stackoverflow.com/questions/5101974/net-orm-comparison/5102461#5102461
  [5]: https://stackoverflow.com/questions/5101974/net-orm-comparison/5105917#5105917

.net ORM Comparison

Is it using some kind of byte codes modification to the original classes?

Or, maybe Hibernate get the dirty state by compare the given object with previously persisted version?

I&#39;m having a problem with `hashCode()` and `equals()` methods for complicated objects. I feel it would be very slow to compute hash code if the object has collection members, and cyclic references are also a problem.

If Hibernate won&#39;t use `hashCode()`/`equals()` to check the dirty state, I guess I should not use `equals()`/`hashCode()` for the entity object (not value object), but I&#39;m also afraid if the same operator (`==`) is not enough.

So, the questions are:

1. How does Hibernate know if a property of an object is changed?

2. Do you suggest to override the `hashCode()`/`equals()` methods for complicated objects? What if they contains cyclic references?

    And, also, 

3. Would `hashCode()`/`equals()` with only the `id` field be enough?


How does Hibernate detect dirty state of an entity object?

What is the difference between Unidirectional and Bidirectional associations?

Since the table generated in the db are all the same,so the only difference I found is that each side of the bidiretional assocations will have a refer to the other,and the unidirectional not.


**This is a Unidirectional association**

    public class User {
    	private int		id;
    	private String	name;
    	@ManyToOne
    	@JoinColumn(
    			name = &quot;groupId&quot;)
    	private Group	group;
    }
    
    public class Group {
    	private int		id;
    	private String	name;
    }
    
**The Bidirectional association**
    
    public class User {
    	private int		id;
    	private String	name;
    	@ManyToOne
    	@JoinColumn(
    			name = &quot;groupId&quot;)
    	private Group	group;
    }
    public class Group {
    	private int			id;
    	private String		name;
    	@OneToMany(mappedBy=&quot;group&quot;)
    	private List&lt;User&gt;	users;
    }


The difference is whether the group holds a reference of the user.

So I wonder if this is the only difference? which is recommended?

What is the difference between Unidirectional and Bidirectional JPA and Hibernate associations?

I just begin my JPA 2.0 studies, and I have this piece of code:

    em = SessionFactory.startSession();
    tx = em.getTransaction();

My problem is: I&#39;m not sure if I completly understand the difference between the use of a session and the use of a transaction. In a few lines, can anyone please tell me the biggest differences between them ? Thanks !




What is the difference between a session and a transaction in JPA 2.0?

I&#39;ve just started using EF code first, so I&#39;m a total beginner in this topic.

I wanted to create relations between Teams and Matches:

1 match = 2 teams (home, guest) and result. 

I thought it&#39;s easy to create such a model, so I started coding:

    public class Team
    {
        [Key]
        public int TeamId { get; set;} 
        public string Name { get; set; }

        public virtual ICollection&lt;Match&gt; Matches { get; set; }
    }
   

    public class Match
    {
        [Key]
        public int MatchId { get; set; }

        [ForeignKey(&quot;HomeTeam&quot;), Column(Order = 0)]
        public int HomeTeamId { get; set; }
        [ForeignKey(&quot;GuestTeam&quot;), Column(Order = 1)]
        public int GuestTeamId { get; set; }

        public float HomePoints { get; set; }
        public float GuestPoints { get; set; }
        public DateTime Date { get; set; }

        public virtual Team HomeTeam { get; set; }
        public virtual Team GuestTeam { get; set; }
    }

And I get an exception: 

&gt; The referential relationship will result in a cyclical reference that is not allowed. [ Constraint name = Match_GuestTeam ]

How can I create such a model, with 2 foreign keys to the same table?

Entity Framework Code First - two Foreign Keys from same table

Django has some good automatic serialization of ORM models returned from DB to JSON format.

How to serialize SQLAlchemy query result to JSON format? 

I tried `jsonpickle.encode` but it encodes query object itself.
I tried `json.dumps(items)` but it returns

    TypeError: &lt;Product(&#39;3&#39;, &#39;some name&#39;, &#39;some desc&#39;)&gt; is not JSON serializable

Is it really so hard to serialize SQLAlchemy ORM objects to JSON /XML? Isn&#39;t there any default serializer for it? It&#39;s very common task to serialize ORM query results nowadays.

What I need is just to return JSON or XML data representation of SQLAlchemy query result.

SQLAlchemy objects query result in JSON/XML format is needed to be used in javascript datagird (JQGrid http://www.trirand.com/blog/)

How to serialize SqlAlchemy result to JSON?

I must be missing something trivial with SQLAlchemy&#39;s cascade options because I cannot get a simple cascade delete to operate correctly -- if a parent element is a deleted, the children persist, with `null` foreign keys. 

I&#39;ve put a concise test case here:

    from sqlalchemy import Column, Integer, ForeignKey
    from sqlalchemy.orm import relationship
    
    from sqlalchemy import create_engine
    from sqlalchemy.orm import sessionmaker
    from sqlalchemy.ext.declarative import declarative_base
    
    Base = declarative_base()
    
    class Parent(Base):
        __tablename__ = &quot;parent&quot;
        id = Column(Integer, primary_key = True)
    
    class Child(Base):
        __tablename__ = &quot;child&quot;
        id = Column(Integer, primary_key = True)
        parentid = Column(Integer, ForeignKey(Parent.id))
        parent = relationship(Parent, cascade = &quot;all,delete&quot;, backref = &quot;children&quot;)
    
    engine = create_engine(&quot;sqlite:///:memory:&quot;)
    Base.metadata.create_all(engine)
    Session = sessionmaker(bind=engine)
    
    session = Session()
    
    parent = Parent()
    parent.children.append(Child())
    parent.children.append(Child())
    parent.children.append(Child())
    
    session.add(parent)
    session.commit()
    
    print &quot;Before delete, children = {0}&quot;.format(session.query(Child).count())
    print &quot;Before delete, parent = {0}&quot;.format(session.query(Parent).count())
    
    session.delete(parent)
    session.commit()
    
    print &quot;After delete, children = {0}&quot;.format(session.query(Child).count())
    print &quot;After delete parent = {0}&quot;.format(session.query(Parent).count())
    
    session.close()

Output:

    Before delete, children = 3
    Before delete, parent = 1
    After delete, children = 3
    After delete parent = 0

There is a simple, one-to-many relationship between Parent and Child. The script creates a parent, adds 3 children, then commits. Next, it deletes the parent, but the children persist. Why? How do I make the children cascade delete?


SQLAlchemy: cascade delete

Here&#39;s my (PostgreSQL) table --

    test=&gt; create table people (name varchar primary key,
                                marriage_status varchar) ; 

    test=&gt; insert into people values (&#39;Ken&#39;, &#39;married&#39;);
    test=&gt; insert into people values (&#39;May&#39;, &#39;single&#39;);
    test=&gt; insert into people values (&#39;Joe&#39;, NULL);

I want to select all people that are **not** known to be married, i.e., including those with NULL marriage_status.

This does **not** work --

    test=&gt; select * from people where marriage_status != &#39;married&#39; ; 
     name | marriage_status 
    ------+-----------------
     May  | single
    (1 row)

Of course this does --

    test=&gt; select * from people where marriage_status != &#39;married&#39;
           or marriage_status is NULL ; 
     name | marriage_status 
    ------+-----------------
     May  | single
     Joe  | 

The problem is that I&#39;m accessing it from SQLAlchemy with --

    ...filter(or_(people.marriage_status!=&#39;married&#39;,
                  people.marriage_status is None))

which gets translated to --

    SELECT people.name as name,
           people.marriage_status as marriage_status
    FROM people 
    WHERE people.marriage_status != %(status_1)s OR False
    sqlalchemy.engine.base.Engine.... {&#39;status_1&#39;: &#39;married&#39;}

And does **not** work --

    test=&gt; select * from people where marriage_status != &#39;married&#39;
           or False; 
     name | marriage_status 
    ------+-----------------
     May  | single
    (1 row)

neither does --

    test=&gt; select * from people where marriage_status != &#39;married&#39;
           or NULL; 
     name | marriage_status 
    ------+-----------------
     May  | single
    (1 row)

How should I select NULL values through SQLAlchemy?

Select NULL Values in SQLAlchemy

I&#39;d really like to be able to print out valid SQL for my application, including values, rather than bind parameters, but it&#39;s not obvious how to do this in SQLAlchemy (by design, I&#39;m fairly sure). 

Has anyone solved this problem in a general way?

SQLAlchemy: print the actual query

I was following the guide here:

http://www.sqlalchemy.org/docs/orm/examples.html?highlight=versioning#versioned-objects

and have come across an issue. I have defined my relationships like:

    generic_ticker = relation(&#39;MyClass&#39;, backref=backref(&quot;stuffs&quot;))

with strings so it doesn&#39;t care about the import order of my model modules. This all works fine normally, but when I use the versioning meta I get the following error:

&gt; sqlalchemy.exc.InvalidRequestError: When initializing mapper Mapper|MyClass|stuffs, expression &#39;Trader&#39; failed to locate a name (&quot;name &#39;MyClass&#39; is not defined&quot;). If this is a class name, consider adding this relationship() to the &lt;class &#39;gm3.model.aum.MyClass&#39;&gt; class after both dependent classes have been defined.

I tracked down the error to:

      File &quot;/home/nick/workspace/gm3/gm3/lib/history_meta.py&quot;, line 90, in __init__
        mapper = class_mapper(cls)
      File &quot;/home/nick/venv/tg2env/lib/python2.6/site-packages/sqlalchemy/orm/util.py&quot;, line 622, in class_mapper
        mapper = mapper.compile()

----

    class VersionedMeta(DeclarativeMeta):
        def __init__(cls, classname, bases, dict_):
            DeclarativeMeta.__init__(cls, classname, bases, dict_)
    
            try:
                mapper = class_mapper(cls)
                _history_mapper(mapper)
            except UnmappedClassError:
                pass

I fixed the problem by putting the try: except stuff in a lambda and running them all after all the imports have happened. This works but seems a bit rubbish, any ideas of how to fix this is a better way?

Thanks!

**Update**

The problem is not actually about import order. The versioning example is designed such that mapper requires compilation in costructor of each versioned class. And compilation fails when related classes are not yet defined. In case of circular relations there is no way to make it working by changing definition order of mapped classes.

**Update 2**

As the above update states (I didn&#39;t know you could edit other people&#39;s posts on here :)) this is likely due to circular references. In which case may be someone will find my hack useful (I&#39;m using it with turbogears) (Replace VersionedMeta and add in create_mappers global in history_meta)

    create_mappers = []
    class VersionedMeta(DeclarativeMeta):
        def __init__(cls, classname, bases, dict_):
            DeclarativeMeta.__init__(cls, classname, bases, dict_)
            #I added this code in as it was crashing otherwise
            def make_mapper():
                try:
                    mapper = class_mapper(cls)
                    _history_mapper(mapper)
                except UnmappedClassError:
                    pass
                
            create_mappers.append(lambda: make_mapper())

Then you can do something like the following in your models \_\_init\_\_.py

    # Import your model modules here.
    from myproj.lib.history_meta import create_mappers
        
    from myproj.model.misc import *
    from myproj.model.actor import *
    from myproj.model.stuff1 import *
    from myproj.model.instrument import *
    from myproj.model.stuff import *
    
    #setup the history
    [func() for func in create_mappers]

That way it create the mappers only after all the classes have been defined.

**Update 3**
Slightly unrelated but I came across a duplicate primary key error in some circumstances (committing 2 changes to the same object in one go). My workaround has been to add a new primary auto-incrementing key. Of course you can&#39;t have more than 1 with mysql so I had to de-primary key the existing stuff used to create the history table. Check out my overall code (including a hist_id and getting rid of the foreign key constraint):
    
    &quot;&quot;&quot;Stolen from the offical sqlalchemy recpies
    &quot;&quot;&quot;
    from sqlalchemy.ext.declarative import DeclarativeMeta
    from sqlalchemy.orm import mapper, class_mapper, attributes, object_mapper
    from sqlalchemy.orm.exc import UnmappedClassError, UnmappedColumnError
    from sqlalchemy import Table, Column, ForeignKeyConstraint, Integer
    from sqlalchemy.orm.interfaces import SessionExtension
    from sqlalchemy.orm.properties import RelationshipProperty
    from sqlalchemy.types import DateTime
    import datetime
    from sqlalchemy.orm.session import Session
    
    def col_references_table(col, table):
        for fk in col.foreign_keys:
            if fk.references(table):
                return True
        return False
    
    def _history_mapper(local_mapper):
        cls = local_mapper.class_
    
        # set the &quot;active_history&quot; flag
        # on on column-mapped attributes so that the old version
        # of the info is always loaded (currently sets it on all attributes)
        for prop in local_mapper.iterate_properties:
            getattr(local_mapper.class_, prop.key).impl.active_history = True
    
        super_mapper = local_mapper.inherits
        super_history_mapper = getattr(cls, &#39;__history_mapper__&#39;, None)
    
        polymorphic_on = None
        super_fks = []
        if not super_mapper or local_mapper.local_table is not super_mapper.local_table:
            cols = []
            for column in local_mapper.local_table.c:
                if column.name == &#39;version&#39;:
                    continue
                
                col = column.copy()
                col.unique = False
                
                #don&#39;t auto increment stuff from the normal db
                if col.autoincrement:
                    col.autoincrement = False
                #sqllite falls over with auto incrementing keys if we have a composite key
                if col.primary_key:
                    col.primary_key = False
                    
                if super_mapper and col_references_table(column, super_mapper.local_table):
                    super_fks.append((col.key, list(super_history_mapper.base_mapper.local_table.primary_key)[0]))
    
                cols.append(col)
    
                if column is local_mapper.polymorphic_on:
                    polymorphic_on = col
    
            #if super_mapper:
            #    super_fks.append((&#39;version&#39;, super_history_mapper.base_mapper.local_table.c.version))
            
            cols.append(Column(&#39;hist_id&#39;, Integer, primary_key=True, autoincrement=True))
            cols.append(Column(&#39;version&#39;, Integer))
            cols.append(Column(&#39;changed&#39;, DateTime, default=datetime.datetime.now))
            
            if super_fks:
                cols.append(ForeignKeyConstraint(*zip(*super_fks)))
    
            table = Table(local_mapper.local_table.name + &#39;_history&#39;, local_mapper.local_table.metadata,
                          *cols, mysql_engine=&#39;InnoDB&#39;)
        else:
            # single table inheritance.  take any additional columns that may have
            # been added and add them to the history table.
            for column in local_mapper.local_table.c:
                if column.key not in super_history_mapper.local_table.c:
                    col = column.copy()
                    super_history_mapper.local_table.append_column(col)
            table = None
    
        if super_history_mapper:
            bases = (super_history_mapper.class_,)
        else:
            bases = local_mapper.base_mapper.class_.__bases__
        versioned_cls = type.__new__(type, &quot;%sHistory&quot; % cls.__name__, bases, {})
    
        m = mapper(
                versioned_cls, 
                table, 
                inherits=super_history_mapper, 
                polymorphic_on=polymorphic_on,
                polymorphic_identity=local_mapper.polymorphic_identity
                )
        cls.__history_mapper__ = m
    
        if not super_history_mapper:
            cls.version = Column(&#39;version&#39;, Integer, default=1, nullable=False)
    
    create_mappers = []
    
    class VersionedMeta(DeclarativeMeta):
        def __init__(cls, classname, bases, dict_):
            DeclarativeMeta.__init__(cls, classname, bases, dict_)
            #I added this code in as it was crashing otherwise
            def make_mapper():
                try:
                    mapper = class_mapper(cls)
                    _history_mapper(mapper)
                except UnmappedClassError:
                    pass
                
            create_mappers.append(lambda: make_mapper())
    
    def versioned_objects(iter):
        for obj in iter:
            if hasattr(obj, &#39;__history_mapper__&#39;):
                yield obj
    
    def create_version(obj, session, deleted = False):
        obj_mapper = object_mapper(obj)
        history_mapper = obj.__history_mapper__
        history_cls = history_mapper.class_
    
        obj_state = attributes.instance_state(obj)
    
        attr = {}
    
        obj_changed = False
    
        for om, hm in zip(obj_mapper.iterate_to_root(), history_mapper.iterate_to_root()):
            if hm.single:
                continue
    
            for hist_col in hm.local_table.c:
                if hist_col.key == &#39;version&#39; or hist_col.key == &#39;changed&#39; or hist_col.key == &#39;hist_id&#39;:
                    continue
    
                obj_col = om.local_table.c[hist_col.key]
    
                # get the value of the
                # attribute based on the MapperProperty related to the
                # mapped column.  this will allow usage of MapperProperties
                # that have a different keyname than that of the mapped column.
                try:
                    prop = obj_mapper.get_property_by_column(obj_col)
                except UnmappedColumnError:
                    # in the case of single table inheritance, there may be 
                    # columns on the mapped table intended for the subclass only.
                    # the &quot;unmapped&quot; status of the subclass column on the 
                    # base class is a feature of the declarative module as of sqla 0.5.2.
                    continue
    
                # expired object attributes and also deferred cols might not be in the
                # dict.  force it to load no matter what by using getattr().
                if prop.key not in obj_state.dict:
                    getattr(obj, prop.key)
    
                a, u, d = attributes.get_history(obj, prop.key)
    
                if d:
                    attr[hist_col.key] = d[0]
                    obj_changed = True
                elif u:
                    attr[hist_col.key] = u[0]
                else:
                    # if the attribute had no value.
                    attr[hist_col.key] = a[0]
                    obj_changed = True
    
        if not obj_changed:
            # not changed, but we have relationships.  OK
            # check those too
            for prop in obj_mapper.iterate_properties:
                if isinstance(prop, RelationshipProperty) and \
                    attributes.get_history(obj, prop.key).has_changes():
                    obj_changed = True
                    break
    
        if not obj_changed and not deleted:
            return
    
        attr[&#39;version&#39;] = obj.version
        hist = history_cls()
        for key, value in attr.iteritems():
            setattr(hist, key, value)
        
        obj.version += 1
        session.add(hist)
        
    class VersionedListener(SessionExtension):
        def before_flush(self, session, flush_context, instances):
            for obj in versioned_objects(session.dirty):
                create_version(obj, session)
            for obj in versioned_objects(session.deleted):
                create_version(obj, session, deleted = True)




SQLAlchemy versioning cares about class import order

I&#39;m trying to create a directory if the path doesn&#39;t exist, but the ! (not) operator doesn&#39;t work. I&#39;m not sure how to negate in Python... What&#39;s the correct way to do this?

    if (!os.path.exists(&quot;/usr/share/sounds/blues&quot;)):
            proc = subprocess.Popen([&quot;mkdir&quot;, &quot;/usr/share/sounds/blues&quot;])
            proc.wait()



Negation in Python

In my application I use several [profiles](http://blog.springsource.com/2011/02/14/spring-3-1-m1-introducing-profile/) to make certain beans eligible for autowiring. What I&#39;m missing is the possibility to make a bean eligible for autowiring when a certain profile is NOT active. 

The best way of doing it that I thought about is like this:

1. Let&#39;s suppose we have a list of all possible profiles, e.g. {A, B, C, D}.
2. Profiles active for particular execution are {A, C}.
3. What I do is I create artificial profiles for all possible profiles which are not active. In the example case I would create {not_B, not_D} profiles.
4. The beans I want to be active based on not active profile `X` I make active for profile `not_X`. In my case if I wanted a bean to be eligible for autowiring when profile B is not active, I would annotate them `@Profile(&quot;not_B&quot;)`

This solution however requires an up-front knowledge about all possible profiles.

Can you think of any better solution?

Including bean definition when a profile is NOT active

Can I use `~A` to invert a numpy array of booleans, instead of the rather awkward functions `np.logical_and()` and `np.invert()`? 

Indeed, `~` seems to work fine, but I can&#39;t find it in any nympy reference manual, and - more alarmingly - it certainly does _not_ work with scalars (e.g. `bool(~True)` returns `True` !), so I&#39;m a little bit worried ...

Inverting a numpy boolean array using ~

Given this input:

    [
      {
        &quot;Id&quot;: &quot;cb94e7a42732b598ad18a8f27454a886c1aa8bbba6167646d8f064cd86191e2b&quot;,
        &quot;Names&quot;: [
          &quot;condescending_jones&quot;,
          &quot;loving_hoover&quot;
        ]
      },
      {
        &quot;Id&quot;: &quot;186db739b7509eb0114a09e14bcd16bf637019860d23c4fc20e98cbe068b55aa&quot;,
        &quot;Names&quot;: [
          &quot;foo_data&quot;
        ]
      },
      {
        &quot;Id&quot;: &quot;a4b7e6f5752d8dcb906a5901f7ab82e403b9dff4eaaeebea767a04bac4aada19&quot;,
        &quot;Names&quot;: [
          &quot;jovial_wozniak&quot;
        ]
      },
      {
        &quot;Id&quot;: &quot;76b71c496556912012c20dc3cbd37a54a1f05bffad3d5e92466900a003fbb623&quot;,
        &quot;Names&quot;: [
          &quot;bar_data&quot;
        ]
      }
    ]

I&#39;m trying to construct a filter with [jq](http://stedolan.github.io/jq/) that returns all objects with `Id`s that **do not** contain &quot;data&quot; in the inner `Names` array, with the output being newline-separated.  For the above data, the output I&#39;d like is:

    cb94e7a42732b598ad18a8f27454a886c1aa8bbba6167646d8f064cd86191e2b
    a4b7e6f5752d8dcb906a5901f7ab82e403b9dff4eaaeebea767a04bac4aada19

I think I&#39;m somewhat close with this:

    (. - select(.Names[] contains(&quot;data&quot;))) | .[] .Id

but the `select` filter is not correct and it doesn&#39;t compile (get `error: syntax error, unexpected IDENT`).

How to filter an array of objects based on values in an inner array with jq?

Is there a short negation of `%in%` in R like `!%in%` or `%!in%`?


----------

Of course I can negate `c(&quot;A&quot;, &quot;B&quot;) %in% c(&quot;B&quot;, &quot;C&quot;)` by `!(c(&quot;A&quot;, &quot;B&quot;) %in% c(&quot;B&quot;, &quot;C&quot;))` (cf. [this question][1]) but I would prefere a more straight forward approach and save a pair of brackets (alike presumably most people would prefer `c(&quot;A&quot;, &quot;B&quot;) != c(&quot;B&quot;, &quot;C&quot;)` over `!(c(&quot;A&quot;, &quot;B&quot;) == c(&quot;B&quot;, &quot;C&quot;))`).


  [1]: https://stackoverflow.com/questions/5831794/opposite-of-in

Content Type	Original Author	Original Content on Stackoverflow
Question	Jérôme Pigeot	View Question on Stackoverflow
Solution 1 - Orm	Maxim Sloyko	View Answer on Stackoverflow
Solution 2 - Orm	Jossy	View Answer on Stackoverflow

how to pass a not like operator in a sqlalchemy ORM query

Orm Problem Overview

Orm Solutions

Solution 1 - Orm

Solution 2 - Orm

Using DataContractSerializer to serialize, but can't deserialize back

If I use C-Style casts in my C++ project, is it worth refactoring to C++ casts?

Attributions