import com.mendix.systemwideinterfaces.core.meta.IMetaObject; //导入依赖的package包/类
private IMendixObject handleMxObject(IContext context, Map<String,IMendixObject> existingMetaObjects, IMetaObject metaObject) throws CoreException
{
	String completeName = metaObject.getName();
	IMendixObject object;
	if(!existingMetaObjects.containsKey(completeName) && !this.builder.allNewModules)
	{
		object = Core.instantiate(context, MxObjectType.getType());
		existingMetaObjects.put(completeName, object);

		object.setValue(context, MxObjectType.MemberNames.CompleteName.toString(), completeName);
		object.setValue(context, MxObjectType.MemberNames.Name.toString(), completeName.substring(completeName.indexOf(".")+1));
		object.setValue(context, MxObjectType.MemberNames.Module.toString(), completeName.substring(0,completeName.indexOf(".")));
	}
	else
		object = existingMetaObjects.get(completeName);

	if( object != null ) {
		List<IMendixIdentifier> superObjectIds = new ArrayList<IMendixIdentifier>();
		for(IMetaObject superObject : metaObject.getSuperObjects()) {
			IMendixObject superMxObject = this.handleMxObject(context, existingMetaObjects, superObject);
			if( superMxObject != null )
				superObjectIds.add(superMxObject.getId());
		}
		
		object.setValue(context, MxObjectType.MemberNames.MxObjectType_SubClassOf_MxObjectType.toString(), superObjectIds);
		object.setValue(context, MxObjectType.MemberNames.PersistenceType.toString(), (metaObject.isPersistable() ? PersistenceType.Persistable.toString() : PersistenceType.Non_persistent.toString())  );
		
		if( this.builder.moduleMap.get(metaObject.getModuleName()) != null ) {
			object.setValue(context, MxObjectType.MemberNames.MxObjectType_Module.toString(), this.builder.moduleMap.get(metaObject.getModuleName()).getId());
		}
		
		Core.commit(context, object);
	}
	
	return object;
}
 

import com.mendix.systemwideinterfaces.core.meta.IMetaObject; //导入依赖的package包/类
private IMetaObject mockIMetaObject(SimpleEntry<String, IMetaPrimitive.PrimitiveType>... entries) {
  IMetaObject metaObject = mock(IMetaObject.class);
  when(metaObject.getName()).thenReturn(entityName);

  final Collection<IMetaPrimitive> primitives = new ArrayList<>();

  Arrays.asList(entries).forEach(entry -> {
    IMetaPrimitive metaPrimitive = mock(IMetaPrimitive.class);
    when(metaPrimitive.getName()).thenReturn(entry.getKey());
    when(metaPrimitive.getType()).thenReturn(entry.getValue());
    when(metaObject.getMetaPrimitive(entry.getKey())).thenReturn(metaPrimitive);
    primitives.add(metaPrimitive);
  });

  Mockito.<Collection<? extends IMetaPrimitive>>when(metaObject.getMetaPrimitives()).thenReturn(primitives);
  return metaObject;
}
 

import com.mendix.systemwideinterfaces.core.meta.IMetaObject; //导入依赖的package包/类
@Test public void testSomeResults() throws SQLException {
  IMendixObject resultObject = mock(IMendixObject.class);

  when(connectionManager.getConnection(anyString(), anyString(), anyString())).thenReturn(connection);
  when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
  when(preparedStatement.executeQuery()).thenReturn(resultSet);
  when(objectInstantiator.instantiate(anyObject(), anyString())).thenReturn(resultObject);
  when(resultSetMetaData.getColumnName(anyInt())).thenReturn("a", "b");
  when(resultSetMetaData.getColumnCount()).thenReturn(2);
  when(resultSet.getMetaData()).thenReturn(resultSetMetaData);
  when(resultSet.getBoolean(anyInt())).thenReturn(true);
  when(resultSet.next()).thenReturn(true, true, true, true, false);

  IMetaObject metaObject = mockIMetaObject(entry("a", Boolean), entry("b", Boolean));
  Stream<IMendixObject> result = jdbcConnector.executeQuery(jdbcUrl, userName, password, metaObject, sqlQuery, context);

  assertEquals(4, result.count());

  verify(objectInstantiator, times(4)).instantiate(context, entityName);
  verify(connectionManager).getConnection(jdbcUrl, userName, password);
  verify(connection).prepareStatement(sqlQuery);
  verify(resultSet, times(3)).getMetaData();
  verify(resultSetMetaData).getColumnCount();
  verify(resultSet, times(5)).next();
}
 

import com.mendix.systemwideinterfaces.core.meta.IMetaObject; //导入依赖的package包/类
@Test public void testResultForBoolean() throws SQLException {
  IMendixObject resultObject = mock(IMendixObject.class);

  when(connectionManager.getConnection(anyString(), anyString(), anyString())).thenReturn(connection);
  when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
  when(preparedStatement.executeQuery()).thenReturn(resultSet);
  when(objectInstantiator.instantiate(anyObject(), anyString())).thenReturn(resultObject);

  when(resultSetMetaData.getColumnCount()).thenReturn(1);
  when(resultSetMetaData.getColumnName(1)).thenReturn("Boolean");
  when(resultSet.getMetaData()).thenReturn(resultSetMetaData);
  when(resultSet.next()).thenReturn(true, false);

  // As Mockito does not allow to return null, we should not mock getting Boolean
  // when(resultSet.getBoolean(1)).thenReturn(null);

  IMetaObject metaObject = mockIMetaObject(entry("Boolean", Boolean), entry("String", String));
  Stream<IMendixObject> result = jdbcConnector.executeQuery(jdbcUrl, userName, password, metaObject, sqlQuery, context);
  assertEquals(1, result.count());

  verify(resultObject).setValue(context, "Boolean", false);
  verify(objectInstantiator, times(1)).instantiate(context, entityName);
  verify(resultSet, times(2)).next();
}
 

import com.mendix.systemwideinterfaces.core.meta.IMetaObject; //导入依赖的package包/类
@Test public void testNoResults() throws Exception {
  IMendixObject resultObject = mock(IMendixObject.class);

  when(connectionManager.getConnection(anyString(), anyString(), anyString())).thenReturn(connection);
  when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
  when(preparedStatement.executeQuery()).thenReturn(resultSet);
  when(objectInstantiator.instantiate(anyObject(), anyString())).thenReturn(resultObject);
  when(resultSetMetaData.getColumnCount()).thenReturn(2);
  when(resultSetMetaData.getColumnName(1)).thenReturn("a");
  when(resultSetMetaData.getColumnName(2)).thenReturn("b");
  when(resultSet.getMetaData()).thenReturn(resultSetMetaData);
  when(resultSet.next()).thenReturn(false);

  IMetaObject metaObject = mockIMetaObject(entry("a", String), entry("b", Boolean));
  Stream<IMendixObject> result = jdbcConnector.executeQuery(jdbcUrl, userName, password, metaObject, sqlQuery, context);

  assertEquals(0, result.count());

  verify(objectInstantiator, never()).instantiate(context, entityName);
  verify(resultSet, times(1)).next();
}
 

import com.mendix.systemwideinterfaces.core.meta.IMetaObject; //导入依赖的package包/类
private IMetaObject mockMetaObjectWithAllPrimitives() {
  final IMetaObject metaObject = mock(IMetaObject.class);
  final Collection<? extends IMetaPrimitive> allPrimitives = Arrays.asList(
      integerPrimitive,
      autoNumberPrimitive,
      longPrimitive,
      booleanPrimitive,
      decimalPrimitive,
      floatPrimitive,
      currencyPrimitive,
      hashStringPrimitive,
      enumPrimitive,
      stringPrimitive,
      binaryPrimitive,
      dateTimePrimitive
  );
  Mockito.<Collection<? extends IMetaPrimitive>>when(metaObject.getMetaPrimitives()).thenReturn(allPrimitives);
  return metaObject;
}
 

import com.mendix.systemwideinterfaces.core.meta.IMetaObject; //导入依赖的package包/类
public static DataService getServiceForEntity(String entityType) {
	if (servicesByEntity.containsKey(entityType)) {
		return servicesByEntity.get(entityType);
	} else if (entitiesWithoutService.contains(entityType)) {
		return null;
	} else {
		//if not look into super entitites as well!
		IMetaObject meta = Core.getMetaObject(entityType);
		if (meta.getSuperObject() != null) {
			DataService superService = getServiceForEntity(meta.getSuperName());
			if (superService != null) {
				servicesByEntity.put(entityType, superService);
				return superService;
			}
		}
		entitiesWithoutService.add(entityType); //no service. Remember that
		return null;
	}
}
 

import com.mendix.systemwideinterfaces.core.meta.IMetaObject; //导入依赖的package包/类
private void handleMembers(IContext context, IMetaObject metaObject, IMendixObject curObject) throws CoreException
{
	Map<String,IMendixObject> membersByName = new HashMap<String, IMendixObject>();
	List<IMendixObject> existingMembers = Core.retrieveXPathQuery(context, "//" + MxObjectMember.getType() + "[" + MxObjectMember.MemberNames.MxObjectMember_MxObjectType + "='" + curObject.getId().toLong() + "']");
	for(IMendixObject obj : existingMembers)
		membersByName.put((String)obj.getValue(context, MxObjectMember.MemberNames.AttributeName.toString()), obj);

	List<IMendixObject> memberList = new ArrayList<IMendixObject>();
	for(IMetaPrimitive metaPrimitive : metaObject.getMetaPrimitives())
	{
		String name = metaPrimitive.getName();
		if(metaPrimitive.getType() == PrimitiveType.Enum)
		{
			if(membersByName.containsKey(name))
			{
				IMendixObject curMember = membersByName.get(name);
				if(MxObjectEnum.getType().equals(curMember.getType()))
				{
					memberList.add(this.handleEnumMember(context, curMember, metaPrimitive, curObject));
					membersByName.remove(name);
				}
				else
				{
					Core.delete(context, curMember);
					memberList.add(this.handleEnumMember(context, null, metaPrimitive, curObject));
				}
			}
			else
				memberList.add(this.handleEnumMember(context, null, metaPrimitive, curObject));
		}
		else
		{
			processMember(context, curObject, membersByName, memberList, metaPrimitive, name);
		}
	}		
	Core.commit(context, memberList);

	this.builder.removeDeletedObjects(context, membersByName);
}
 

import com.mendix.systemwideinterfaces.core.meta.IMetaObject; //导入依赖的package包/类
@Test public void testSomeResultsWithTwoColumns() throws SQLException {
  String columnName1 = "TestColumnName1";
  String columnName2 = "TestColumnName2";
  String row1Value1 = "TestRow1Value1";
  String row1Value2 = "TestRow1Value2";
  String row2Value1 = "TestRow2Value1";
  String row2Value2 = "TestRow2Value2";

  IMendixObject resultObject1 = mock(IMendixObject.class);
  IMendixObject resultObject2 = mock(IMendixObject.class);

  when(connectionManager.getConnection(anyString(), anyString(), anyString())).thenReturn(connection);
  when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
  when(preparedStatement.executeQuery()).thenReturn(resultSet);
  when(objectInstantiator.instantiate(anyObject(), anyString())).thenReturn(resultObject1, resultObject2);
  when(resultSetMetaData.getColumnCount()).thenReturn(2);
  when(resultSetMetaData.getColumnName(1)).thenReturn(columnName1);
  when(resultSetMetaData.getColumnName(2)).thenReturn(columnName2);
  when(resultSet.getMetaData()).thenReturn(resultSetMetaData);
  when(resultSet.next()).thenReturn(true, true, false);
  when(resultSet.getString(1)).thenReturn(row1Value1, row2Value1);
  when(resultSet.getString(2)).thenReturn(row1Value2, row2Value2);

  IMetaObject metaObject = mockIMetaObject(entry(columnName1, String), entry(columnName2, String));
  Stream<IMendixObject> result = jdbcConnector.executeQuery(jdbcUrl, userName, password, metaObject, sqlQuery, context);
  assertEquals(2, result.count());

  verify(resultObject1).setValue(context, columnName1, row1Value1);
  verify(resultObject1).setValue(context, columnName2, row1Value2);
  verify(resultObject2).setValue(context, columnName1, row2Value1);
  verify(resultObject2).setValue(context, columnName2, row2Value2);
  verify(objectInstantiator, times(2)).instantiate(context, entityName);
  verify(resultSet, times(3)).next();
}
 

import com.mendix.systemwideinterfaces.core.meta.IMetaObject; //导入依赖的package包/类
private IMetaObject mockMetaObject() {
  final IMetaObject metaObject = mock(IMetaObject.class);
  final Collection<? extends IMetaPrimitive> stringPrimitives = Arrays.asList(
      mockMetaPrimitive("a", PrimitiveType.String),
      mockMetaPrimitive("b", PrimitiveType.String),
      mockMetaPrimitive("c", PrimitiveType.String)
  );
  Mockito.<Collection<? extends IMetaPrimitive>>when(metaObject.getMetaPrimitives()).thenReturn(stringPrimitives);
  return metaObject;
}
 

import com.mendix.systemwideinterfaces.core.meta.IMetaObject; //导入依赖的package包/类
private IMetaObject mockMetaObjectWithThreePrimitives() {
  final IMetaObject metaObject = mock(IMetaObject.class);
  final Collection<? extends IMetaPrimitive> allPrimitives = Arrays.asList(
      integerPrimitive,
      booleanPrimitive,
      stringPrimitive
  );
  Mockito.<Collection<? extends IMetaPrimitive>>when(metaObject.getMetaPrimitives()).thenReturn(allPrimitives);
  return metaObject;
}
 

import com.mendix.systemwideinterfaces.core.meta.IMetaObject; //导入依赖的package包/类
@Override
public java.util.List<IMendixObject> executeAction() throws Exception
{
	// BEGIN USER CODE
	IMetaObject metaObject = resultObject.getMetaObject();
	Stream<IMendixObject> resultStream = connector.executeQuery(
	    this.jdbcUrl, this.userName, this.password, metaObject, this.sql, this.getContext());
	List<IMendixObject> resultList = resultStream.collect(Collectors.toList());
	logNode.trace(String.format("Result list count: %d", resultList.size()));

	return resultList;
	// END USER CODE
}
 

import com.mendix.systemwideinterfaces.core.meta.IMetaObject; //导入依赖的package包/类
public Stream<IMendixObject> executeQuery(final String jdbcUrl, final String userName, final String password, final IMetaObject metaObject, final String sql,
    final IContext context) throws SQLException {
  String entityName = metaObject.getName();
  
  Function<Map<String, Optional<Object>>, IMendixObject> toMendixObject = columns -> {
    IMendixObject obj = objectInstantiator.instantiate(context, entityName);
    
    BiConsumer<String, Optional<Object>> setMemberValue = (name, value) -> {
      PrimitiveType type = metaObject.getMetaPrimitive(name).getType();
      // convert to suitable value (different for Binary type)
      Function<Object, Object> toSuitableValue = toSuitableValue(type);
      // for Boolean type, convert null to false
      Supplier<Object> defaultValue = () -> type == PrimitiveType.Boolean ? Boolean.FALSE : null;
      // apply two functions declared above
      Object convertedValue = value.map(toSuitableValue).orElseGet(defaultValue);
      // update object with converted value
      if (type == PrimitiveType.HashString)
        ((MendixHashString) obj.getMember(context, name)).setInitialHash((String) convertedValue);
      else
        obj.setValue(context, name, convertedValue);
    };
    
    columns.forEach(setMemberValue);
    logNode.trace("Instantiated object: " + obj);
    return obj;
  };

  return executeQuery(jdbcUrl, userName, password, metaObject, sql).map(toMendixObject);
}
 

import com.mendix.systemwideinterfaces.core.meta.IMetaObject; //导入依赖的package包/类
/**
 * Determines on which settings this index was build. If changed, a new index should be generated
 * @param def
 * @return
 */
private String calculateServiceConfigurationHash(DataServiceDefinition def) {
	IMetaObject returnType = Core.getMetaObject(Core.getReturnType(def.getOnPublishMicroflow()).getObjectType());
	JSONObject exporttype = JSONSchemaBuilder.build(returnType);
	
	return StringUtils.join(new String[] {
		def.getSourceEntity(), 
		def.getSourceKeyAttribute(), 
		def.getSourceConstraint(),
		exporttype.toString()
	},";");
}
 

import com.mendix.systemwideinterfaces.core.meta.IMetaObject; //导入依赖的package包/类
private static Set<String> getAssociationsReferingToFileDocs(
		IMetaObject meta) {
	Set<String> names = new HashSet<String>();
	for (IMetaAssociation assoc : meta.getMetaAssociationsParent()) {
		if (assoc.getType() == AssociationType.REFERENCE && Core.isSubClassOf(FileDocument.entityName, assoc.getChild().getName()))
			names.add(assoc.getName());
	}
	return names;
}
 

import com.mendix.systemwideinterfaces.core.meta.IMetaObject; //导入依赖的package包/类
private JSONObject associationToJSONType(IMetaAssociation assoc) {
	IMetaObject child = assoc.getChild();
	
	JSONObject type = null;
	
	//some kind of foreign key
	if (child.isPersistable()) {
		//only if there is a service available for that type;
		if (RestServices.getServiceForEntity(child.getName()) != null ) {
			type = new JSONObject()
				.put("type", "string")
				.put("title", String.format("Reference to a(n) '%s'", child.getName()));
		}
	}
		
	//persistent object, describe this object in the service as well
	else {
		buildTypeDefinition(child); //make sure the type is available in the schema
		String targetType = typeMap.get(child.getName());
		type = new JSONObject().put("$ref", "#/definitions/" + targetType);
		if ("type1".equals(targetType))
			hasReferenceToRoot  = true;
	}

	//assoc should be included?
	if (type == null)
		return null;
	
	
	//make sure referencesets require arrays
	if (assoc.getType() == AssociationType.REFERENCESET)
		type = new JSONObject().put("type", "array").put("items", type);
	
	//make sure null refs are supported
	else /* not a refset */
		type = orNull(type);
	
	return type;
}
 

import com.mendix.systemwideinterfaces.core.meta.IMetaObject; //导入依赖的package包/类
private static void duplicateReverseAssociations(IContext ctx, IMendixObject src, IMendixObject tar, 
        List<String> toskip, List<String> tokeep, List<String> revAssocs, 
        List<String> skipEntities, List<String> skipModules,
        Map<IMendixIdentifier, IMendixIdentifier> mappedObjects) throws CoreException
{
	for(String fullAssocName : revAssocs) {
		String[] parts = fullAssocName.split("/"); 
		
		if (parts.length != 1 && parts.length != 3) //specifying entity has no meaning anymore, but remain backward compatible. 
			throw new IllegalArgumentException("Reverse association is not defined correctly, please mention the relation name only: '" + fullAssocName + "'");

		String assocname = parts.length == 3 ? parts[1] : parts[0]; //support length 3 for backward compatibility
		
		IMetaAssociation massoc = src.getMetaObject().getDeclaredMetaAssociationChild(assocname);

		if (massoc != null) {
			IMetaObject relationParent = massoc.getParent();
		    // if the parent is in the exclude list, we can't clone the parent, and setting the 
			// references to the newly cloned target object will screw up the source data.
			if (skipEntities.contains(relationParent.getName()) || skipModules.contains(relationParent.getModuleName())){
		        throw new IllegalArgumentException("A reverse reference has been specified that starts at an entity in the exclude list, this is not possible to clone: '" + fullAssocName + "'");
		    }
		    
		    //MWE: what to do with reverse reference sets? -> to avoid spam creating objects on 
		    //reverse references, do not support referenceset (todo: we could keep a map of converted guids and reuse that!)
			if (massoc.getType() == AssociationType.REFERENCESET) {
				throw new IllegalArgumentException("It is not possible to clone reverse referencesets: '" + fullAssocName + "'");
			}
			
			List<IMendixObject> objs = Core.retrieveXPathQueryEscaped(ctx, "//%s[%s='%s']", 
			        relationParent.getName(), assocname, String.valueOf(src.getId().toLong()));
			
			for(IMendixObject obj : objs) {
			    @SuppressWarnings("unused") // object is unused on purpose
                   IMendixIdentifier refObj = getCloneOfObject(ctx, obj, toskip, tokeep, revAssocs, skipEntities, skipModules, mappedObjects);
                   // setting reference explicitly is not necessary, this has been done in the 
                   // duplicate() call.
			}
		}
	}
}
 

import com.mendix.systemwideinterfaces.core.meta.IMetaObject; //导入依赖的package包/类
private IMetaObject mockMetaObjectWithStringPrimitive() {
  final IMetaObject metaObject = mock(IMetaObject.class);
  final Collection<? extends IMetaPrimitive> allPrimitives = Arrays.asList(stringPrimitive);
  Mockito.<Collection<? extends IMetaPrimitive>>when(metaObject.getMetaPrimitives()).thenReturn(allPrimitives);
  return metaObject;
}
 

import com.mendix.systemwideinterfaces.core.meta.IMetaObject; //导入依赖的package包/类
public ResultSetReader(final ResultSet resultSet, final IMetaObject metaObject) {
  this.rsIter = new ResultSetIterator(resultSet, metaObject);
}
 

import com.mendix.systemwideinterfaces.core.meta.IMetaObject; //导入依赖的package包/类
public ResultSetIterator(final ResultSet resultSet, final IMetaObject metaObject) {
  this.resultSet = resultSet;
  this.metaObject = metaObject;
  this.columnInfos = createColumnInfos(resultSet);
}