Persisting array of strings with greenDao

Question

I'm trying to map an object to database with greenDao. But when it comes to arrays, I don't know how to do it. After receiving JSON from network and deserializing it with GSON, I have objects defined by this class:

public class Car {
   Long carId;
   String name;
   ArrayList<String> listOfLinks;
} 

In case of a a different architecture, like this:

public class Car {
   Long carId;
   String name;
   ArrayList<Link> listOfLinks;
} 

public class Link {
   Long carId;
   String link;
}

----
Entity cars = schema.addEntity("Car");
cars.addLongProperty("carId").primaryKey();
cars.addStringProperty("name");

Entity links = schema.addEntity("Link");
links.addStringProperty("name");
links.addIdProperty().primaryKey().notNull().autoincrement();

Property linkProperty = links.addLongProperty("carId").getProperty();
ToMany carToLinks = cars.addToMany(link, linkProperty);

It would is easy. Define some relations, define properties, add foreign key and your done. With arrays I have no clue what to do. Ideas?

Answer 1

Since JPA 2.0, you can use an element collection to persist a Collection of value types. You just need to annotate the attribute with @ElementCollection and the persistence provider will persist the elements of the Collection in an additional database table.

@Entity
public class Author {
 
    @ElementCollection
    private List<String> phoneNumbers = new ArrayList<String>();
  
}

The element collection might seem easier to use than an entity with a one-to-many association. But it has one major drawback: The elements of the collection have no id and Hibernate can’t address them individually.

When you add a new Object to the List or remove an existing one, Hibernate deletes all elements and inserts a new record for each item in the List.

Let’s take a quick look at an example. The following code snippet selects an Author entity and adds a second phoneNumber to the element collection.

EntityManager em = emf.createEntityManager();
em.getTransaction().begin();
 
Author a = em.find(Author.class, 1L);
a.getPhoneNumbers().add("42424242");
 
em.getTransaction().commit();
em.close();

an element collection is an easy but not the most efficient option to store a list of value types in the database. You should, therefore, only use it for very small collections so that Hibernate doesn’t perform too many SQL statements. In all other cases, a one-to-many association is the better approach.

Answer 2

Relation toMany is useful when you have a list of your not primitive object, that you can declare like entity that have its own id etc etc etc, and make list of entities (with toMeny). By doing that greenDao makes another table in the base for you new entity with the foreign key of the base entity that contains list. When you have list of primitive type the only way to do is to make converter that converts List into one of the primitive types that greenDao works naturally. You have to do something like this `

    import org.greenrobot.greendao.converter.PropertyConverter;
    import java.util.Arrays;
    import java.util.List;

    /**
    *DOLE BREEE SQLITE BREEEEEE!!!** 
    *i choosed to convert List into one string 
    *that is going to be saved in database, and vice versa 
    */

    public class GreenConverter implements PropertyConverter, String> {
    @Override
    public List convertToEntityProperty(String databaseValue) {
    if (databaseValue == null) {
    return null;
    }
    else {
    List<String> lista = Arrays.asList(databaseValue.split(","));
    return lista;
    }
    }

    @Override
    public String convertToDatabaseValue(List<String> entityProperty) {
        if(entityProperty==null){
            return null;
        }
        else{
            StringBuilder sb= new StringBuilder();
            for(String link:entityProperty){
                sb.append(link);
                sb.append(",");
            }
            return sb.toString();
        }
    }
    }

now above all the properties that are List you have to put @Convert(converter=yourconverterclass.class, columnType = String.class)

 @Entity
public class ShipEntry {

@Id(autoincrement = true)
private long ship_id;
private String name;
private String model;
private String manufacturer;
private String starship_class;

@Convert(converter = GreenConverter.class, columnType = String.class)
private List<String> pilots;

@Convert(converter = GreenConverter.class, columnType = String.class)
private List<String> films ;
}

you can create Converter as a inner class of entitiy, and in that case it has to be declared as staticthat is the only way i have found, but the bad side is that you can not use property that you are converting into query. There might me some typo, but i hope this helps to solve your problem

Answer 3

I also have the same issue, and there no answer (not in official docs, not in google). Please explain how to map List to Entity?

public class Car {
   Long carId;
   String name;
   ArrayList<String> listOfLinks;
}

Can I do something like this?

@Entity(active = true, nameInDb = "CARS")
    public class Car {
        @Id
        private Long id;

        @NotNull
        @Unique
        private String remoteId;

        @ToMany(joinProperties = {
                @JoinProperty(name = "remoteId", referencedName = "carRemoteId")
        })
        private List<Links> listOfLinks;
    }


@Entity(active = true, nameInDb = "LISTOFLINKS")
public class Links{

    @Id
    private Long id;

    @NotNull
    @Unique
    private String remoteId;

    @SerializedName("listOfLinks")
    @Expose
    private String listOfLinks;//is it possible?????

    private String carRemoteId;
}

Answer 4

That approach is not common when using relational databases. This is commonly done using to-many relations : instead of using a list of String, you can create a Link entity and then use a list of Link.