Gordon Yorke (EclipseLink Architecture Committee Member, TopLink Core Technical Lead, JPA 2.0 Expert Group Member) wrote a good answer on this topic so instead of paraphrasing him, I&#39;ll quote [his answer][1]:


&gt; The difference between `optional` and
&gt; `nullable` is the scope at which they
&gt; are evaluated. The definition of
&gt; &#39;`optional`&#39; talks about property and
&gt; field values and suggests that this
&gt; feature should be evaluated within the
&gt; runtime. &#39;`nullable`&#39; is only in
&gt; reference to database columns. 
&gt; 
&gt; If an implementation chooses to
&gt; implement `optional` then those
&gt; properties should be evaluated in
&gt; memory by the Persistence Provider and
&gt; an exception raised before SQL is sent
&gt; to the database otherwise when using
&gt; &#39;`updatable=false`&#39; &#39;`optional`&#39;
&gt; violations would never be reported.

  [1]: http://markmail.org/message/osod6rsauwbnkvya

So I tried the @Basic(optional=false) annotation using JPA 2.1 (EclipseLink) and it turns out the annotation is ignored in actual usage (at least for a String field). (e.g. entityManager.persist calls).

So I went to the specification and read up about it.
Here is what the spec has to say:  
http://download.oracle.com/otndocs/jcp/persistence-2.0-fr-oth-JSpec/

&gt; Basic(optional): Whether the value of the field or property may be
&gt; null. This is a hint and is disregarded for primitive types; it may be
&gt; used in schema generation.

So I think this sentence explains the real use case for Basic(optional) it is used in schema generation. (That is: when you generate CREATE TABLE SQL from Java Entity classes. This is something Hibernate can do for example.)




I have an input field that is rendered with a template like so:

    &lt;div class=&quot;field&quot;&gt;
       {{ form.city }}
    &lt;/div&gt;

Which is rendered as:

    &lt;div class=&quot;field&quot;&gt;
        &lt;input id=&quot;id_city&quot; type=&quot;text&quot; name=&quot;city&quot; maxlength=&quot;100&quot; /&gt;
    &lt;/div&gt;

Now suppose I want to add an `autocomplete=&quot;off&quot;` attribute to the input element that is rendered, how would I do that?  Or `onclick=&quot;xyz()&quot;` or `class=&quot;my-special-css-class&quot;`?


Django: How do I add arbitrary html attributes to input fields on a form?

I&#39;m working on a completion (intellisense) facility for C# in emacs. 

The idea is, if a user types a fragment, then asks for completion via a particular keystroke combination, the completion facility will use .NET reflection to determine the possible completions.  

Doing this requires that the type of the thing being completed, be known.  If it&#39;s a string, there&#39;s a known set of possible methods and properties; if it&#39;s an Int32, it has a separate set, and so on.  

Using semantic, a code lexer/parser package available in emacs, I can locate the variable declarations, and their types.  Given that, it&#39;s straightforward to use reflection to get the methods and properties on the type, and then present the list of options to the user. (Ok, not quite *straightforward* to do *within* emacs, but using [the ability to run a powershell process inside emacs][1], it becomes much easier. I write a custom .NET assembly to do reflection, load it into the powershell, and then elisp running within emacs can send commands to powershell and read responses, via comint.  As a result emacs can get the results of reflection quickly.)

The problem arrives when the code uses `var` in the declaration of the thing being completed. That means the type is not explicitly specified, and completion won&#39;t work. 

How can I reliably determine the actual type used, when the variable is declared with the `var` keyword?  Just to be clear, I don&#39;t need to determine it at runtime.  I want to determine it at &quot;Design time&quot;.

So far I have these ideas:

&lt;ol&gt;
&lt;li&gt;compile and invoke:
 
&lt;ul&gt;
&lt;li&gt;extract the declaration statement, eg `var foo = &quot;a string value&quot;;`&lt;/li&gt;
&lt;li&gt;concatenate a statement `foo.GetType();`&lt;/li&gt;
&lt;li&gt;dynamically compile the resulting C# fragment it into a new assembly &lt;/li&gt;
&lt;li&gt;load the assembly into a new AppDomain, run the framgment and get the return type.&lt;/li&gt;
&lt;li&gt;unload and discard the assembly&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;I know how to do all this.  But it sounds awfully heavyweight, for each completion request in the editor. &lt;/p&gt;
&lt;p&gt;
I suppose I don&#39;t need a fresh new AppDomain every time.  I could re-use a single AppDomain for multiple temporary assemblies, and amortize the cost of setting it
up and tearing it down, across multiple completion requests.  That&#39;s more a tweak of the basic idea.  
&lt;/p&gt;

&lt;/li&gt;

&lt;li&gt;compile and inspect IL    
&lt;p&gt;Simply compile the declaration into a module, and then inspect the IL, to determine the actual type that was inferred by the compiler.   How would this be possible?  What would I use to examine the IL? &lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt; 


Any better ideas out there? Comments? suggestions? 


----

**EDIT** - thinking about this further, compile-and-invoke is not acceptable, because the invoke may have side effects. So the first option must be ruled out. 

Also, I think I cannot assume the presence of .NET 4.0.  

----

**UPDATE** - The correct answer, unmentioned above, but gently pointed out by Eric Lippert, is to implement a full fidelity type inference system.  It;s the only way to reliably determine the type of a var at design time.  But, it&#39;s also not easy to do.  Because I suffer no illusions that I want to attempt to build such a thing, I took the shortcut of option 2  - extract the relevant declaration code, and compile it, then inspect the resulting IL.  

This actually works, for a fair subset of the completion scenarios. 

For example, suppose in the following code fragments, the ? is the position at which the user asks for completion.  This works: 

    var x = &quot;hello there&quot;; 
    x.?

The completion realizes that x is a String, and provides the appropriate options. It does this by generating and then compiling the following source code: 

    namespace N1 {
      static class dmriiann5he { // randomly-generated class name
        static void M1 () {
           var x = &quot;hello there&quot;; 
        }
      }
    }

...and then inspecting the IL with simple reflection.

This also works:

    var x = new XmlDocument();
    x.? 

The engine adds the appropriate using clauses to the generated source code, so that it compiles properly, and then the IL inspection is the same. 

This works, too:

    var x = &quot;hello&quot;; 
    var y = x.ToCharArray();    
    var z = y.?

It just means the IL inspection has to find the type of the third local variable, instead of the first.  

And this:

    var foo = &quot;Tra la la&quot;;
    var fred = new System.Collections.Generic.List&lt;String&gt;
        {
            foo,
            foo.Length.ToString()
        };
    var z = fred.Count;
    var x = z.?

...which is just one level deeper that the prior example. 

But, what *doesn&#39;t* work is completion on any local variable whose initialization depends at any point on an instance member, or local method argument. Like: 

    var foo = this.InstanceMethod();
    foo.?

Nor LINQ syntax.

I&#39;ll have to think about how valuable those things are before I consider addressing them via what is definitely a &quot;limited design&quot; (polite word for hack) for completion. 
 
An approach to addressing the issue with dependencies on method arguments or instance methods would be to replace, in the fragment of code that gets generated, compiled and then IL analyzed, the references to those things with &quot;synthetic&quot; local vars of the same type.  

----

**Another Update** - completion on vars that depend on instance members, now works.  

What I did was interrogate the type (via semantic), and then generate synthetic stand-in members for all existing members.  For a C# buffer like this: 

    public class CsharpCompletion
    {
        private static int PrivateStaticField1 = 17;

        string InstanceMethod1(int index)
        {
            ...lots of code here...
            return result;
        }

        public void Run(int count)
        {
            var foo = &quot;this is a string&quot;;
            var fred = new System.Collections.Generic.List&lt;String&gt;
            {
                foo,
                foo.Length.ToString()
            };
            var z = fred.Count;
            var mmm = count + z + CsharpCompletion.PrivateStaticField1;
            var nnn = this.InstanceMethod1(mmm);
            var fff = nnn.?

            ...more code here...

...the generated code that gets compiled, so that I can learn from the output IL the type of the local var nnn, looks like this: 

    namespace Nsbwhi0rdami {
      class CsharpCompletion {
        private static int PrivateStaticField1 = default(int);
        string InstanceMethod1(int index) { return default(string); }

        void M0zpstti30f4 (int count) {
           var foo = &quot;this is a string&quot;;
           var fred = new System.Collections.Generic.List&lt;String&gt; { foo, foo.Length.ToString() };
           var z = fred.Count;
           var mmm = count + z + CsharpCompletion.PrivateStaticField1;
           var nnn = this.InstanceMethod1(mmm);
          }
      }
    }


All of the instance and static type members are available in the skeleton code.  It compiles successfully.  At that point, determining the type of the local var is straightforward via Reflection. 

What makes this possible is:

 - the ability to run powershell in emacs
 - the C# compiler is really fast. On my machine, it takes about 0.5s to compile an in-memory assembly. Not fast enough for between-keystrokes analysis, but fast enough to support the on-demand generation of completion lists. 

I haven&#39;t looked into LINQ yet.   
That will be a much bigger problem because the semantic lexer/parser emacs has for C#, doesn&#39;t &quot;do&quot; LINQ. 


  [1]: http://blogs.msdn.com/powershell/archive/2008/04/15/powershell-running-inside-of-emacs.aspx

How can I reliably determine the type of a variable that is declared using var at design time?

What&#39;s the difference between `@Basic(optional = false)` and `@Column(nullable = false)` in JPA persistence?

@Basic(optional = false) vs @Column(nullable = false) in JPA

<p>What's the difference between <code>@Basic(optional = false)</code> and <code>@Column(nullable = false)</code> in JPA persistence?</p>


In some interfaces I wrote I&#39;d like to name generic type parameters with more than one character to make the code more readable.

Something like....

    Map&lt;Key,Value&gt;

Instead of this...

    Map&lt;K,V&gt;

But when it comes to methods, the type-parameters look like java-classes which is also confusing.

    public void put(Key key, Value value)

This seems like Key and Value are classes. I found or thought of some notations, but nothing like a convention from Sun or a general best-practice.

Alternatives I guessed or found...

    Map&lt;KEY,VALUE&gt;
    Map&lt;TKey,TValue&gt;
    



Generic type parameter naming convention for Java (with multiple chars)?

Suppose, I am doing a full build on my large project which has 7 modules and on the 6th module, the build failed because a test failed. Is there any way by which I can start the build from the point it failed?



Can we start the maven build from the point where it failed

Why are Python exceptions named &quot;Error&quot; (e.g. `ZeroDivisionError`, `NameError`, `TypeError`)
and not &quot;Exception&quot; (e.g. `ZeroDivisionException`, `NameException`, `TypeException`).

I come from a Java background and started to learn Python recently, as such this is confusing because in Java there is a distinction between errors and exceptions.

Is there a difference in Python also or not?

Why are Python exceptions named &quot;Error&quot;?

I have an class defining an immutable value type that I now need to serialize. The immutability comes from the final fields which are set in the constructor. I&#39;ve tried serializing, and it works (surprisingly?) - but I&#39;ve no idea how.

Here&#39;s an example of the class

    public class MyValueType implements Serializable
    {
        private final int value;
    
        private transient int derivedValue;
    
        public MyValueType(int value)
        {
            this.value = value;
            this.derivedValue = derivedValue(value);
        }
    
        // getters etc...
    }

Given that the class doesn&#39;t have a no arg constructor, how can it be instantiated and the final field set? 

(An aside - I noticed this class particularly because IDEA wasn&#39;t generating a &quot;no serialVersionUID&quot; inspection warning for this class, yet successfully generated warnings for other classes that I&#39;ve just made serializable.)




How does java serialization deserialize final fields when no default constructor specified?

For converting a byte array to a double I found this:

    //convert 8 byte array to double
    int start=0;//???
    int i = 0;
		int len = 8;
		int cnt = 0;
		byte[] tmp = new byte[len];
		for (i = start; i &lt; (start + len); i++) {
			tmp[cnt] = arr[i];
			//System.out.println(java.lang.Byte.toString(arr[i]) + &quot; &quot; + i);
			cnt++;
		}
		long accum = 0;
		i = 0;
		for ( int shiftBy = 0; shiftBy &lt; 64; shiftBy += 8 ) {
			accum |= ( (long)( tmp[i] &amp; 0xff ) ) &lt;&lt; shiftBy;
			i++;
		}
		
            return Double.longBitsToDouble(accum);


But I could not find anything which would convert a double into a byte array.

How can I convert a byte array into a double and back?

&gt; The no-argument constructor is a
&gt; requirement (tools like Hibernate use
&gt; reflection on this constructor to
&gt; instantiate objects).

I got this hand-wavy answer but could somebody explain further? Thanks

Why does Hibernate require no argument constructor?

My Java bean has a childCount property. This property is **not mapped to a database column**. Instead, it should be **calculated by the database with a `COUNT()` function** operating on the join of my Java bean and its children. It would be even better if this property could be calculated on demand / &quot;lazily&quot;, but this is not mandatory.

In the worst case scenario, I can set this bean&#39;s property with HQL or the Criteria API, but I would prefer not to.

The Hibernate `@Formula` annotation may help, but I could barely find any documentation.

Any help greatly appreciated. Thanks.

How to map calculated properties with JPA and Hibernate

To empty a database table, I use this SQL Query:

    TRUNCATE TABLE `books`

How to I truncate a table using Django&#39;s models and ORM?

I&#39;ve tried this, but it doesn&#39;t work:

    Book.objects.truncate()

How to TRUNCATE TABLE using Django&#39;s ORM?

I am a newbie to Java Persistence API and Hibernate. 

What is the difference between [`FetchType.LAZY`](http://docs.oracle.com/javaee/7/api/javax/persistence/FetchType.html) and [`FetchType.EAGER`](http://docs.oracle.com/javaee/7/api/javax/persistence/FetchType.html) in Java Persistence API? 

Difference between FetchType LAZY and EAGER in Java Persistence API?

How do I set a default value in Hibernate field?

How to set a default entity property value with Hibernate

In the spirit of type safety associated with the [CriteriaQuery](http://java.sun.com/javaee/6/docs/api/javax/persistence/criteria/CriteriaQuery.html) JPA 2.0 also has an API to support [Metamodel](http://java.sun.com/javaee/6/docs/tutorial/doc/gjiup.html) representation of entities. 

Is anyone aware of a fully functional implementation of this API (to generate the Metamodel as opposed to creating the metamodel classes manually)? It would be awesome if someone also knows the steps for setting this up in Eclipse (I assume it&#39;s as simple as setting up an annotation processor, but you never know).

EDIT:
Just stumbled across [Hibernate JPA 2 Metamodel Generator ](http://docs.jboss.org/hibernate/stable/jpamodelgen/reference/en-US/html_single/). But the issue remains since I can&#39;t find any download links for the jar.

EDIT 2:
Awhile has passed since I asked this question, but I thought I&#39;d come back and add a link to the [Hibernate JPA Model Generator project on SourceForge](http://sourceforge.net/projects/hibernate/files/hibernate-jpamodelgen/)

How to generate the JPA entity Metamodel?

I have a Java bean. Now, I want to be sure that the field should be unique.

I am using the following code:

    @UniqueConstraint(columnNames={&quot;username&quot;})
    public String username;

But I&#39;m getting some error:

    @UniqueConstraint is dissallowed for this location

What&#39;s the proper way to use unique constraints?

**Note:** I am using play framework.


@UniqueConstraint annotation in Java

The terms &quot;jta-datasource&quot; and &quot;resource-local datasource&quot; are a little vague to me. I&#39;m putting down what I am understanding ( or assuming ) and I&#39;d like you to say where I&#39;m right / wrong.

 - The same database can be referred to as a jta-datasource or as a resource local datasource
 - If mentioned as jta-datasource, then the beans / other classes can use JTA. Hence, UserTransaction interface
 - Cannot use [CMT][1] / [BMT][2] if the datasource is resource local 
 - If mentioned as resource local datasource, transactions are not JTA aware. Code can use EntityTransaction interface but not UserTransaction interface

Thanks!

    


  [1]: http://docs.oracle.com/javaee/6/tutorial/doc/bncij.html
  [2]: http://docs.oracle.com/javaee/6/tutorial/doc/bnciy.html

Content Type	Original Author	Original Content on Stackoverflow
Question	joaosavio	View Question on Stackoverflow
Solution 1 - Java	Pascal Thivent	View Answer on Stackoverflow
Solution 2 - Java	Ray Hulha	View Answer on Stackoverflow

@Basic(optional = false) vs @Column(nullable = false) in JPA

Java Problem Overview

Java Solutions

Solution 1 - Java

Solution 2 - Java

How can I reliably determine the type of a variable that is declared using var at design time?

Django: How do I add arbitrary html attributes to input fields on a form?

Attributions