import org.eclipse.collections.api.map.MutableMap; //导入依赖的package包/类
private ImmutableList<ImmutableMap<String, String>> convertToParamList(String templateParamAttr) {
    if (templateParamAttr == null) {
        return Lists.immutable.of(Maps.immutable.<String, String>empty());
    }

    ImmutableList<String> paramGroups = ArrayAdapter.adapt(templateParamAttr.split(";")).toImmutable();
    return paramGroups.collect(new Function<String, ImmutableMap<String, String>>() {
        @Override
        public ImmutableMap<String, String> valueOf(String paramGroup) {
            String[] paramStrs = paramGroup.split(",");
            MutableMap<String, String> params = Maps.mutable.empty();
            for (String paramStr : paramStrs) {
                String[] paramParts = paramStr.split("=");
                params.put(paramParts[0], paramParts[1]);
            }

            return params.toImmutable();
        }
    });
}
 

import org.eclipse.collections.api.map.MutableMap; //导入依赖的package包/类
@Override
public String prepare(String content, Change change, DbEnvironment env) {
    MutableMap<String, String> tokens = Maps.mutable.<String, String>empty()
            .withKeyValue("dbSchemaSuffix", env.getDbSchemaSuffix())
            .withKeyValue("dbSchemaPrefix", env.getDbSchemaPrefix());

    for (Schema schema : env.getSchemas()) {
        PhysicalSchema physicalSchema = env.getPhysicalSchema(schema.getName());
        tokens.put(schema.getName() + "_physicalName", physicalSchema.getPhysicalName());
        if (env.getPlatform() != null) {
            tokens.put(schema.getName() + "_schemaSuffixed", env.getPlatform().getSchemaPrefix(physicalSchema));
            tokens.put(schema.getName() + "_subschemaSuffixed", env.getPlatform().getSubschemaPrefix(physicalSchema));
        }
    }

    if (env.getDefaultTablespace() != null) {
        tokens.put("defaultTablespace", env.getDefaultTablespace());
    }

    tokens.putAll(env.getTokens().castToMap());  // allow clients to override these values if needed

    return new Tokenizer(tokens, env.getTokenPrefix(), env.getTokenSuffix()).tokenizeString(content);
}
 

import org.eclipse.collections.api.map.MutableMap; //导入依赖的package包/类
private ImmutableMap<String, String> getSourceEncodings(Config metadataConfig) {
    if (metadataConfig.hasPath("sourceEncodings")) {
        Config sourceEncodings = metadataConfig.getConfig("sourceEncodings");

        MutableMap<String, String> encodingsMap = Maps.mutable.empty();
        for (String encoding : sourceEncodings.root().keySet()) {
            String fileList = sourceEncodings.getString(encoding);
            for (String file : fileList.split(",")) {
                encodingsMap.put(file, encoding);
            }
        }

        return encodingsMap.toImmutable();
    }
    return Maps.immutable.empty();
}
 

import org.eclipse.collections.api.map.MutableMap; //导入依赖的package包/类
private ImmutableMap<ChangeType, Pattern> initPatternMap(Platform platform) {
    MutableMap<String, Pattern> params = Maps.mutable.<String, Pattern>with()
            .withKeyValue(ChangeType.SP_STR, Pattern.compile("(?i)create\\s+proc(?:edure)?\\s+(\\w+)", Pattern.DOTALL))
            .withKeyValue(ChangeType.FUNCTION_STR, Pattern.compile("(?i)create\\s+func(?:tion)?\\s+(\\w+)", Pattern.DOTALL))
            .withKeyValue(ChangeType.VIEW_STR, Pattern.compile("(?i)create\\s+view\\s+(\\w+)", Pattern.DOTALL))
            .withKeyValue(ChangeType.SEQUENCE_STR, Pattern.compile("(?i)create\\s+seq(?:uence)?\\s+(\\w+)", Pattern.DOTALL))
            .withKeyValue(ChangeType.TABLE_STR, Pattern.compile("(?i)create\\s+table\\s+(\\w+)", Pattern.DOTALL))
            .withKeyValue(ChangeType.DEFAULT_STR, Pattern.compile("(?i)create\\s+default\\s+(\\w+)", Pattern.DOTALL))
            .withKeyValue(ChangeType.RULE_STR, Pattern.compile("(?i)create\\s+rule\\s+(\\w+)", Pattern.DOTALL))
            .withKeyValue(ChangeType.USERTYPE_STR, Pattern.compile("(?i)^\\s*sp_addtype\\s+", Pattern.DOTALL))
            .withKeyValue(ChangeType.INDEX_STR, Pattern.compile("(?i)create\\s+(?:unique\\s+)?(?:\\w+\\s+)?index\\s+\\w+\\s+on\\s+(\\w+)", Pattern.DOTALL))
    ;

    MutableMap<ChangeType, Pattern> patternMap = Maps.mutable.<ChangeType, Pattern>with();
    for (String changeTypeName : params.keysView()) {
        if (platform.hasChangeType(changeTypeName)) {
            ChangeType changeType = platform.getChangeType(changeTypeName);
            patternMap.put(changeType, params.get(changeTypeName));
        }
    }

    return patternMap.toImmutable();
}
 

import org.eclipse.collections.api.map.MutableMap; //导入依赖的package包/类
private void verifyCsv(String input, MutableList<String> keyFields, MutableMap<String, String>... rows) throws Exception {
    CsvReaderDataSource ds = new CsvReaderDataSource(CsvStaticDataReader.CSV_V2, "test", new StringReader(input), ',', StringFunctions.toLowerCase(), "null");
    ds.setCatoConfiguration(new CatoSimpleJavaConfiguration(new SimpleCatoProperties(keyFields)));
    ds.init();
    ds.open();
    MutableList<Map<String, Object>> dataRows = IteratorIterate.collect(ds, new Function<CatoDataObject, Map<String, Object>>() {
        @Override
        public Map<String, Object> valueOf(CatoDataObject catoDataObject) {
            Map<String, Object> data = Maps.mutable.empty();
            for (String field : catoDataObject.getFields()) {
                data.put(field, catoDataObject.getValue(field));
            }

            return data;
        }
    }, Lists.mutable.<Map<String, Object>>empty());
    ds.close();


    assertEquals(rows.length, dataRows.size());
    for (int i = 0; i < dataRows.size(); i++) {
        assertEquals(rows[i], dataRows.get(i));
    }
}
 

import org.eclipse.collections.api.map.MutableMap; //导入依赖的package包/类
public IqDataSource(DbEnvironment env, Credential userCredential, int numThreads, IqDataSourceFactory subDataSourceFactory) {
    this.env = env;
    this.subDataSourceFactory = subDataSourceFactory;

    MutableMap<PhysicalSchema, DataSource> dsMap = Maps.mutable.empty();
    for (PhysicalSchema physicalSchema : env.getPhysicalSchemas()) {
        String schema = physicalSchema.getPhysicalName();
        LOG.info("Creating datasource against schema {}", schema);
        DataSource ds = subDataSourceFactory.createDataSource(env,
                userCredential,
                schema,
                numThreads
        );

        dsMap.put(physicalSchema, ds);
    }

    this.dsMap = dsMap.toImmutable();
    this.setCurrentSchema(this.env.getPhysicalSchemas().getFirst());  // set one arbitrarily as the default
}
 

import org.eclipse.collections.api.map.MutableMap; //导入依赖的package包/类
/**
 * Returns true/false if all the schemas in the environment either need rollback (true) or don't (false).
 *
 * If some do and some don't, an exception is thrown.
 */
@Override
public boolean determineRollback(final String productVersion, final ImmutableSet<String> schemas, final DeployExecutionDao deployExecutionDao) {
    MutableMap<String, Boolean> rollbackFlags = schemas.toMap(
            Functions.<String>getPassThru(),
            new Function<String, Boolean>() {
                @Override
                public Boolean valueOf(final String schema) {
                    LOG.info("Checking rollback status on Product Version {} and Schema {}", productVersion, schema);
                    return determineRollbackForSchema(productVersion, deployExecutionDao.getDeployExecutions(schema));
                }
            }
    );

    MutableSet<Boolean> values = rollbackFlags.valuesView().toSet();
    if (values.size() > 1) {
        MutableSetMultimap<Boolean, String> schemasByRollbackFlag = rollbackFlags.flip();
        MutableSet<String> rollbackSchemas = schemasByRollbackFlag.get(Boolean.TRUE);
        MutableSet<String> nonrollbackSchemas = schemasByRollbackFlag.get(Boolean.FALSE);

        throw new IllegalArgumentException("The following schemas were calculated for rollback [" + rollbackSchemas + "], though the rest were not [" + nonrollbackSchemas + "]; cannot proceed in this mixed mode");
    }

    return values.iterator().next().booleanValue();
}
 

import org.eclipse.collections.api.map.MutableMap; //导入依赖的package包/类
@Test
public void getPeopleByLastName()
{
    // Do you recognize this pattern?
    MutableMap<String, MutableList<Person>> lastNamesToPeople = Maps.mutable.empty();
    for (Person person : this.people)
    {
        String lastName = person.getLastName();
        MutableList<Person> peopleWithLastName = lastNamesToPeople.get(lastName);
        if (peopleWithLastName == null)
        {
            peopleWithLastName = Lists.mutable.empty();
            lastNamesToPeople.put(lastName, peopleWithLastName);
        }
        peopleWithLastName.add(person);
    }
    Verify.assertIterableSize(3, lastNamesToPeople.get("Smith"));

    // Hint: use the appropriate method on this.people to create a Multimap<String, Person>
    Multimap<String, Person> byLastNameMultimap = null;

    Verify.assertIterableSize(3, byLastNameMultimap.get("Smith"));
}
 

import org.eclipse.collections.api.map.MutableMap; //导入依赖的package包/类
/**
 * Returns the default name-to-platform mappings. We put this in a separate protected method to allow external
 * distributions to override these values as needed.
 */
protected ImmutableMap<String, String> getDbPlatformMap() {
    MutableMap<String, String> platformByName = Maps.mutable.empty();

    for (String platformName : platformConfigs.root().keySet()) {
        String platformClass = getPlatformConfig(platformName).getString("class");
        platformByName.put(platformName, platformClass);
        LOG.debug("Registering platform {} at class {}", platformName, platformClass);
    }

    return platformByName.toImmutable();
}
 

import org.eclipse.collections.api.map.MutableMap; //导入依赖的package包/类
public void init() {
    this.comparisonCommands = Lists.mutable.empty();
    MutableMap<String, DbDataSource> sourceMap = this.dbDataSources.toMap(DbDataSource.TO_NAME,
            Functions.<DbDataSource>getPassThru());
    for (Pair<String, String> comparisonCommandNamePair : this.comparisonCommandNamePairs) {
        this.comparisonCommands.add(new ComparisonCommand(
                sourceMap.get(comparisonCommandNamePair.getOne())
                , sourceMap.get(comparisonCommandNamePair.getTwo())
        ));
    }
}
 

import org.eclipse.collections.api.map.MutableMap; //导入依赖的package包/类
private static void populateConfig(Config config, MutableMap<String, Object> params, String attr) {
    if (config.hasPath(attr)) {
        Config attrs = config.getConfig(attr);
        MutableMap<String, String> attrsMap = Maps.mutable.empty();
        for (String key : attrs.root().keySet()) {
            attrsMap.put(key, config.getString(attr + "." + key));
        }
        params.put(attr, attrsMap);
    }
}
 

import org.eclipse.collections.api.map.MutableMap; //导入依赖的package包/类
@Override
protected MutableMap<String, ChangeTypeBehavior> getChangeTypeBehaviors() {
    MutableMap<String, ChangeTypeBehavior> changeTypeBehaviors = super.getChangeTypeBehaviors();

    ChangeType routineChangeType = platform().getChangeTypes().detect(Predicates.attributeEqual(ChangeType.TO_NAME, ChangeType.FUNCTION_STR));
    changeTypeBehaviors.put(ChangeType.FUNCTION_STR, new PostgreSqlFunctionChangeTypeBehavior(env, (DbChangeType) routineChangeType, getSqlExecutor(), simpleArtifactDeployer(), grantChangeParser(), graphEnricher(), platform(), getDbMetadataManager()));

    return changeTypeBehaviors;
}
 

import org.eclipse.collections.api.map.MutableMap; //导入依赖的package包/类
@Override
protected MutableMap<String, ChangeTypeBehavior> getChangeTypeBehaviors() {
    MutableMap<String, ChangeTypeBehavior> changeTypeBehaviors = super.getChangeTypeBehaviors();
    changeTypeBehaviors.put(ChangeType.SP_STR, updateRoutineType(ChangeType.SP_STR));
    changeTypeBehaviors.put(ChangeType.FUNCTION_STR, updateRoutineType(ChangeType.FUNCTION_STR));
    return changeTypeBehaviors;
}
 

import org.eclipse.collections.api.map.MutableMap; //导入依赖的package包/类
public void generate(String schema) {
    MutableSet<MyInput> inputs = Sets.mutable.empty();

    inputs.withAll(getUserTypes(numTypes));
    inputs.withAll(getTables());
    inputs.withAll(getViews());
    inputs.withAll(getSps());


    MutableSet<String> types = Sets.mutable.of("table", "view", "sp", "usertype");
    File outputDir = new File("./target/testoutput");
    FileUtils.deleteQuietly(outputDir);
    outputDir.mkdirs();
    for (MyInput input : inputs) {
        MutableMap<String, Object> params = Maps.mutable.<String, Object>empty().withKeyValue(
                "name", input.getName()
        );
        for (String type : types) {
            params.put("dependent" + type + "s", input.getDependenciesByType().get(type));
        }

        File outputFile = new File(outputDir, schema + "/" + input.getType() + "/" + input.getName() + ".sql");
        outputFile.getParentFile().mkdirs();
        TestTemplateUtil.getInstance().writeTemplate("schemagen/" + input.getType() + ".sql.ftl", params, outputFile);
    }

}
 

import org.eclipse.collections.api.map.MutableMap; //导入依赖的package包/类
/**
 * allow for use cases to redeploy changes that require recompiling
 * e.g. to add db objects to the change list to facilitate cases where it depends on another SP that is
 * changing, and so the dependent SP needs to get re-created also
 */
private MutableSet<Change> getObjectChangesRequiringRecompilation(ChangeType changeType, RichIterable<Change> fromSourceList, MutableCollection<Change> changedObjects) {
    if (fromSourceList.isEmpty()) {
        return Sets.mutable.empty();
    }
    // do not log errors as info or above here when creating the graph as we know that we don't have the full graph
    LOG.debug("START BLOCK: Ignore any 'Invalid change found?' errors in this block of code");
    DirectedGraph<Change, DefaultEdge> graph = enricher.createDependencyGraph(fromSourceList.select(Predicates.attributeEqual(Change.TO_CHANGE_TYPE, changeType)), false);
    LOG.debug("END BLOCK: Ignore any 'Invalid change found?' errors in this block of code");

    MutableCollection<Change> changesForType = changedObjects.select(
            Predicates.attributeEqual(Change.TO_CHANGE_TYPE, changeType));
    MutableMap<String, Change> changesForTypeMap = changesForType.toMap(
            Change.objectName(), Functions.<Change>getPassThru());

    MutableSet<Change> newChangesToAdd = HashingStrategySets.mutable.of(HashingStrategies.fromFunction(Change.objectName()));
    for (Change change : changesForType) {
        BreadthFirstIterator<Change, DefaultEdge> dependencyIterator = new BreadthFirstIterator<Change, DefaultEdge>(graph, change);

        MutableSet<Change> dependencies = ListAdapter.adapt(
                IteratorUtils.toList(dependencyIterator)).toSet();
        dependencies.remove(change);  // the iterator result includes the self; we can remove this

        for (Change changeToAddBack : dependencies) {
            if (!changesForTypeMap.containsKey(changeToAddBack.getObjectName())) {
                changeToAddBack.setReason("Re-deploying this object due to change in dependent object ["
                        + change.getObjectName() + "]");
                newChangesToAdd.add(changeToAddBack);
            }
        }
    }
    return newChangesToAdd;
}
 

import org.eclipse.collections.api.map.MutableMap; //导入依赖的package包/类
@Override
public void match(MutableList<UnmatchedIndexMap> allMissingRows, MutableList<UnmatchedIndexMap> allSurplusRows, MutableList<IndexMap> matchedColumns)
{
    List<IndexMap> keyColumnIndices = this.getKeyColumnIndexMaps(matchedColumns);
    if (keyColumnIndices.isEmpty())
    {
        LOGGER.warn("No key columns found!");
        return;
    }
    MutableMap<RowView, MutableList<UnmatchedIndexMap>> missingByKey = UnifiedMap.newMap(allMissingRows.size());
    for (UnmatchedIndexMap expected : allMissingRows)
    {
        ExpectedRowView expectedRowView = new ExpectedRowView(this.expectedData, keyColumnIndices, this.columnComparators, expected.getExpectedIndex());
        missingByKey.getIfAbsentPut(expectedRowView, NEW_LIST).add(expected);
    }
    MutableMap<RowView, MutableList<UnmatchedIndexMap>> surplusByKey = UnifiedMap.newMap(allSurplusRows.size());
    for (UnmatchedIndexMap actual : allSurplusRows)
    {
        ActualRowView actualRowView = new ActualRowView(this.actualData, keyColumnIndices, this.columnComparators, actual.getActualIndex());
        surplusByKey.getIfAbsentPut(actualRowView, NEW_LIST).add(actual);
    }
    for (RowView rowView : missingByKey.keysView())
    {
        MutableList<UnmatchedIndexMap> missing = missingByKey.get(rowView);
        MutableList<UnmatchedIndexMap> surplus = surplusByKey.get(rowView);
        if (Iterate.notEmpty(missing) && Iterate.notEmpty(surplus))
        {
            this.keyGroupPartialMatcher.match(missing, surplus, matchedColumns);
        }
    }
}
 

import org.eclipse.collections.api.map.MutableMap; //导入依赖的package包/类
/**
 * check passing value to map.
 */
@Test
public final void testSetValue() {
    final MutableMap<String, Integer> map = Maps.mutable.of("new", 130);
    pair.put(map);
    assertTrue(map.containsKey("tomato"));
    assertTrue(map.containsValue(120));
}
 

import org.eclipse.collections.api.map.MutableMap; //导入依赖的package包/类
/**
 * check put key-value pair to passed map.
 */
@Test
public final void testSetValue() {
    final MutableMap<String, String> map = Maps.mutable.of("newKey", "newValue");
    twin.put(map);
    assertTrue(map.containsKey("key"));
    assertTrue(map.containsValue("value"));
}
 

import org.eclipse.collections.api.map.MutableMap; //导入依赖的package包/类
@Test
public void getCountsByPetType()
{
    MutableList<PetType> petTypes = this.people.flatCollect(Person::getPets).collect(Pet::getType);

    // Do you recognize this pattern?
    MutableMap<PetType, Integer> petTypeCounts = Maps.mutable.empty();
    for (PetType petType : petTypes)
    {
        Integer count = petTypeCounts.get(petType);
        if (count == null)
        {
            count = 0;
        }
        petTypeCounts.put(petType, count + 1);
    }

    Assert.assertEquals(Integer.valueOf(2), petTypeCounts.get(PetType.CAT));
    Assert.assertEquals(Integer.valueOf(2), petTypeCounts.get(PetType.DOG));
    Assert.assertEquals(Integer.valueOf(2), petTypeCounts.get(PetType.HAMSTER));
    Assert.assertEquals(Integer.valueOf(1), petTypeCounts.get(PetType.SNAKE));
    Assert.assertEquals(Integer.valueOf(1), petTypeCounts.get(PetType.TURTLE));
    Assert.assertEquals(Integer.valueOf(1), petTypeCounts.get(PetType.BIRD));

    // Hint: use the appropriate method on this.people to create a Bag<PetType>
    Bag<PetType> counts = null;
    Assert.assertEquals(2, counts.occurrencesOf(PetType.CAT));
    Assert.assertEquals(2, counts.occurrencesOf(PetType.DOG));
    Assert.assertEquals(2, counts.occurrencesOf(PetType.HAMSTER));
    Assert.assertEquals(1, counts.occurrencesOf(PetType.SNAKE));
    Assert.assertEquals(1, counts.occurrencesOf(PetType.TURTLE));
    Assert.assertEquals(1, counts.occurrencesOf(PetType.BIRD));
}
 

import org.eclipse.collections.api.map.MutableMap; //导入依赖的package包/类
@Test
public void getPeopleByTheirPets()
{
    // Do you recognize this pattern?
    MutableMap<PetType, MutableSet<Person>> peopleByPetType = Maps.mutable.empty();

    for (Person person : this.people)
    {
        MutableList<Pet> pets = person.getPets();
        for (Pet pet : pets)
        {
            PetType petType = pet.getType();
            MutableSet<Person> peopleWithPetType = peopleByPetType.get(petType);
            if (peopleWithPetType == null)
            {
                peopleWithPetType = Sets.mutable.empty();
                peopleByPetType.put(petType, peopleWithPetType);
            }
            peopleWithPetType.add(person);
        }
    }

    Verify.assertIterableSize(2, peopleByPetType.get(PetType.CAT));
    Verify.assertIterableSize(2, peopleByPetType.get(PetType.DOG));
    Verify.assertIterableSize(1, peopleByPetType.get(PetType.HAMSTER));
    Verify.assertIterableSize(1, peopleByPetType.get(PetType.TURTLE));
    Verify.assertIterableSize(1, peopleByPetType.get(PetType.BIRD));
    Verify.assertIterableSize(1, peopleByPetType.get(PetType.SNAKE));

    // Hint: use the appropriate method on this.people with a target collection to create a MutableSetMultimap<String, Person>
    // Hint: this.people is a MutableList, so it will return a MutableListMultimap without a target collection
    MutableSetMultimap<PetType, Person> multimap = null;

    Verify.assertIterableSize(2, multimap.get(PetType.CAT));
    Verify.assertIterableSize(2, multimap.get(PetType.DOG));
    Verify.assertIterableSize(1, multimap.get(PetType.HAMSTER));
    Verify.assertIterableSize(1, multimap.get(PetType.TURTLE));
    Verify.assertIterableSize(1, multimap.get(PetType.BIRD));
    Verify.assertIterableSize(1, multimap.get(PetType.SNAKE));
}