@Override public Session openSession() { RDFConnection connection = repository.openConnection(); SessionImpl session = new SessionImpl(configuration, ontology, connection, getLocales()); if (objectRepositories != null) { for (Map.Entry<String, ObjectRepository> entry : objectRepositories.entrySet()) { session.addParent(entry.getKey(), entry.getValue()); } } return session; }
@Override public ID save(Object instance) { boolean flush = false; if (seen == null) { seen = new HashSet<Object>(); flush = true; } assertMapped(instance); assertHasIdProperty(instance); ID subject = toRDF(instance, null); if (flush) { seen = null; if (flushMode == FlushMode.ALWAYS) { flush(); } } return subject; }
@Override public RDFBeanTransaction beginTransaction() { return beginTransaction(false, -1, java.sql.Connection.TRANSACTION_READ_COMMITTED); }
@Override public void deleteAll(Object... objects) { for (Object object : objects) { deleteInternal(assertMapped(object)); } if (flushMode == FlushMode.ALWAYS) { flush(); } }
@Override public List<ID> saveAll(Object... instances) { List<ID> ids = new ArrayList<ID>(instances.length); seen = new HashSet<Object>(instances.length * 3); for (Object instance : instances) { ids.add(save(assertMapped(instance))); } seen = null; if (flushMode == FlushMode.ALWAYS) { flush(); } return ids; }
private <T> void findInstances(Class<T> clazz, UID type, final Set<T> instances) { MappedClass mappedClass = configuration.getMappedClass(clazz); boolean polymorphic = isPolymorphic(mappedClass); UID context = mappedClass.getContext(); logger.debug("query for " + clazz.getSimpleName() + " instance data"); RDFQuery query = createQuery(mappedClass, type, polymorphic); CloseableIterator<STMT> stmts = query.construct(Blocks.SPOC); Map<ID, Multimap<UID, STMT>> directProps = getPropertiesMap(stmts, false); inverseProps = getInvProperties(mappedClass, directProps.keySet()); Map<ID, T> idToInstance = createInstances(mappedClass, clazz, polymorphic, context, directProps, inverseProps); loadReferences(mappedClass, directProps, directProps.keySet()); T instance = getCached(entry.getKey(), clazz); if (idToInstance.containsKey(entry.getKey())) { PropertiesMap properties = new PropertiesMap(entry.getValue(), inverseProps.get(entry.getKey())); MappedClass mc = resolveMappedClass(mappedClass, properties); bind(mc, entry.getKey(), instance, properties);
Set<ID> ids = new HashSet<ID>(subjects.length); for (ID id : subjects) { if (id != null && getCached(id, clazz) == null) { ids.add(id); return getFromCache(clazz, instances, subjects); boolean polymorphic = isPolymorphic(mappedClass); UID context = mappedClass.getContext(); RDFQuery query = createQuery(mappedClass, null, polymorphic); query.where(QNODE.s.in(ids)); Map<ID, Multimap<UID, STMT>> directProps = getPropertiesMap(stmts, false); return getFromCache(clazz, instances, subjects); inverseProps = getInvProperties(mappedClass, directProps.keySet()); Map<ID, T> idToInstance = createInstances(mappedClass, clazz, polymorphic, context, directProps, inverseProps); loadReferences(mappedClass, directProps, directProps.keySet()); T instance = null; if (subject != null && directProps.containsKey(subject)) { instance = getCached(subject, clazz); if (idToInstance.containsKey(subject)) { PropertiesMap properties = new PropertiesMap(directProps.get(subject), inverseProps.get(subject)); bind(mappedClass, subject, instance, properties);
return (ID) instance; BeanMap beanMap = toBeanMap(Assert.notNull(instance, "instance")); Class<?> clazz = getClass(instance); MappedClass mappedClass = configuration.getMappedClass(clazz); ID subject = resourceCache.get(instance); if (subject == null) { subject = getId(mappedClass, beanMap); put(subject, instance); } else if (seen.add(instance)) { UID context = getContext(clazz, subject, parentContext); boolean update = subject != null && exists(subject, mappedClass, context); subject = assignId(mappedClass, beanMap); context = getContext(clazz, subject, parentContext); put(subject, instance); toRDF(beanMap, subject, context, mappedClass, update);
convertedValue = convertCollection(propertyPath, values, context); convertedValue = convertArray(propertyPath, values, context); convertedValue = convertLocalizedMap(propertyPath, values); } else if (mappedProperty.getType().equals(String.class)) { convertedValue = convertLocalized(propertyPath, values); } else { throw new SessionException("Illegal use of @Localized with " + mappedProperty.getType() + " at " convertedValue = convertMap(propertyPath, values); convertedValue = convertSingleValue(propertyPath, values); convertedValue = convertSingleValue(propertyPath, values);
UID context = getContext(instance, subject, null); BeanMap beanMap = toBeanMap(instance); setId(mappedClass, subject, beanMap); bindDynamicProperties(subject, properties.getDirect(), beanMap, mappedClass); Object convertedValue; try { convertedValue = getValue(path, getPathValue(path, subject, properties, context), context); } catch (InstantiationException e) { throw new SessionException(e);
@Override @SuppressWarnings("unchecked") public ID getId(Object instance) { if (instance instanceof LID) { return identityService.getID((LID) instance); } else { MappedClass mappedClass = configuration.getMappedClass(getClass(assertMapped(instance))); if (instance.getClass().isEnum()) { return new UID(mappedClass.getUID().ns(), ((Enum) instance).name()); } else { BeanMap beanMap = toBeanMap(instance); return getId(mappedClass, beanMap); } } }
@Nullable private <T> T getMappedObject(MappedClass mappedClass, ID subject, Class<T> requiredClass, PropertiesMap properties, boolean polymorphic, UID context, boolean bind) { T instance = null; if (polymorphic) { Collection<ID> mappedTypes = findMappedTypes(subject, context, properties.getDirect()); if (!mappedTypes.isEmpty()) { instance = createInstance(subject, requiredClass, mappedTypes, properties); } else if (properties.getDirect().containsKey(RDF.rest)) { Map<String, NODE> values = new HashMap<String, NODE>(); values.put(RDF.rest.ln(), properties.getDirect().get(RDF.rest).iterator().next().getObject()); if (properties.getDirect().containsKey(RDF.first)) { values.put(RDF.first.ln(), properties.getDirect().get(RDF.first).iterator().next().getObject()); } listCache.put(subject, values); } else { logger.error("got no type for " + subject.getId()); } } else { instance = createInstance(subject, requiredClass, Collections.<ID> emptyList(), properties); } if (instance != null) { put(subject, instance); if (bind) { bind(mappedClass, subject, instance, properties); } } return instance; }
@Before public void setUp() { metadata = new DefaultQueryMetadata(); RDFConnection connection = new MiniRepository().openConnection(); Configuration configuration = new DefaultConfiguration(User.class); Ontology ontology = new ConfigurationOntology(configuration); Session session = new SessionImpl(configuration, new ConfigurationOntology(configuration), connection); builder = new RDFQueryBuilder(connection, session, configuration, ontology, metadata); query = new QueryMixin(metadata); }
public SessionImpl(Configuration configuration, Ontology ontology, RDFConnection connection, Iterable<Locale> locales) { this.configuration = configuration; this.ontology = ontology; this.connection = connection; this.locales = locales; this.identityService = new SessionIdentityService(connection); clear(); }
private <T> void loadAll(Class<T> clazz, Collection<ID> ids, Set<ID> handled) { MappedClass mappedClass = configuration.getMappedClass(clazz); boolean polymorphic = isPolymorphic(mappedClass); UID context = mappedClass.getContext(); logger.debug("query for " + clazz.getSimpleName() + " instance data"); RDFQuery query = createQuery(mappedClass, null, polymorphic); query.where(QNODE.s.in(ids)); CloseableIterator<STMT> stmts = query.construct(Blocks.SPOC); Map<ID, Multimap<UID, STMT>> directProps = getPropertiesMap(stmts, false); inverseProps = getInvProperties(mappedClass, directProps.keySet()); Map<ID, T> idToInstance = createInstances(mappedClass, clazz, polymorphic, context, directProps, inverseProps); loadReferences(mappedClass, directProps, handled); T instance = getCached(entry.getKey(), clazz); if (idToInstance.containsKey(entry.getKey())) { PropertiesMap properties = new PropertiesMap(entry.getValue(), inverseProps.get(entry.getKey())); MappedClass mc = resolveMappedClass(mappedClass, properties); bind(mc, entry.getKey(), instance, properties);
@Override public void delete(Object instance) { deleteInternal(assertMapped(instance)); if (flushMode == FlushMode.ALWAYS) { flush(); } }