Changeset 3053


Ignore:
Timestamp:
01/18/12 19:49:37 (4 months ago)
Author:
kasper
Message:

Ticket #748: Fixed

Location:
AnalyzerBeans/trunk
Files:
15 edited
2 moved

Legend:

Unmodified
Added
Removed

  • AnalyzerBeans/trunk/cli/src/test/java/org/eobjects/analyzer/cli/MainTest.java

    r2817 r3053  
    138138                assertEquals("Filters:", lines[0]); 
    139139 
    140                 assertTrue(out.indexOf("name: Not null") != -1); 
    141                 assertTrue(out.indexOf("- Outcome category: VALID") != -1); 
     140                assertTrue(out.indexOf("name: Null check") != -1); 
     141                assertTrue(out.indexOf("- Outcome category: NOT_NULL") != -1); 
    142142        } 
    143143 

  • AnalyzerBeans/trunk/core/src/main/java/org/eobjects/analyzer/beans/filter/NullCheckFilter.java

    r3043 r3053  
    2323import java.util.List; 
    2424 
     25import org.eobjects.analyzer.beans.api.Alias; 
    2526import org.eobjects.analyzer.beans.api.Configured; 
    2627import org.eobjects.analyzer.beans.api.Description; 
    … …  
    3637import org.eobjects.metamodel.schema.Column; 
    3738 
    38 @FilterBean("Not null") 
     39@FilterBean("Null check") 
     40@Alias("Not null") 
    3941@Description("Filter rows that contain null values.") 
    40 public class NotNullFilter implements QueryOptimizedFilter<ValidationCategory> { 
     42public class NullCheckFilter implements QueryOptimizedFilter<NullCheckFilter.NullCheckCategory> { 
     43 
     44        public static enum NullCheckCategory { 
     45                @Alias("INVALID") 
     46                NULL, 
     47 
     48                @Alias("VALID") 
     49                NOT_NULL; 
     50        } 
    4151 
    4252        @Configured 
    … …  
    4858        boolean considerEmptyStringAsNull = false; 
    4959 
    50         public NotNullFilter() { 
     60        public NullCheckFilter() { 
    5161        } 
    5262 
    53         public NotNullFilter(InputColumn<?>[] columns, boolean considerEmptyStringAsNull) { 
     63        public NullCheckFilter(InputColumn<?>[] columns, boolean considerEmptyStringAsNull) { 
    5464                this(); 
    5565                this.columns = columns; 
    5666                this.considerEmptyStringAsNull = considerEmptyStringAsNull; 
    5767        } 
    58          
     68 
    5969        public void setConsiderEmptyStringAsNull(boolean considerEmptyStringAsNull) { 
    6070                this.considerEmptyStringAsNull = considerEmptyStringAsNull; 
    6171        } 
    62          
     72 
    6373        @Override 
    64         public boolean isOptimizable(ValidationCategory category) { 
     74        public boolean isOptimizable(NullCheckCategory category) { 
    6575                return true; 
    6676        } 
    6777 
    6878        @Override 
    69         public Query optimizeQuery(Query q, ValidationCategory category) { 
    70                 if (category == ValidationCategory.VALID) { 
     79        public Query optimizeQuery(Query q, NullCheckCategory category) { 
     80                if (category == NullCheckCategory.NOT_NULL) { 
    7181                        for (InputColumn<?> col : columns) { 
    7282                                Column column = col.getPhysicalColumn(); 
    … …  
    7787                        } 
    7888                } else { 
    79                         // if INVALID all filter items will be OR'ed. 
     89                        // if NULL all filter items will be OR'ed. 
    8090                        List<FilterItem> filterItems = new ArrayList<FilterItem>(); 
    8191                        for (InputColumn<?> col : columns) { 
    … …  
    96106 
    97107        @Override 
    98         public ValidationCategory categorize(InputRow inputRow) { 
     108        public NullCheckCategory categorize(InputRow inputRow) { 
    99109                for (InputColumn<?> col : columns) { 
    100110                        Object value = inputRow.getValue(col); 
    101111                        if (value == null) { 
    102                                 return ValidationCategory.INVALID; 
     112                                return NullCheckCategory.NULL; 
    103113                        } 
    104114 
    105115                        if (considerEmptyStringAsNull && "".equals(value)) { 
    106                                 return ValidationCategory.INVALID; 
     116                                return NullCheckCategory.NULL; 
    107117                        } 
    108118                } 
    109                 return ValidationCategory.VALID; 
     119                return NullCheckCategory.NOT_NULL; 
    110120        } 
    111121} 

  • AnalyzerBeans/trunk/core/src/main/java/org/eobjects/analyzer/descriptors/AnnotationBasedFilterBeanDescriptor.java

    r3031 r3053  
    2424import java.util.Set; 
    2525 
     26import org.eobjects.analyzer.beans.api.Alias; 
    2627import org.eobjects.analyzer.beans.api.Filter; 
    2728import org.eobjects.analyzer.beans.api.FilterBean; 
    … …  
    3031final class AnnotationBasedFilterBeanDescriptor<F extends Filter<C>, C extends Enum<C>> extends AbstractBeanDescriptor<F> 
    3132                implements FilterBeanDescriptor<F, C> { 
    32          
     33 
    3334        private static final long serialVersionUID = 1L; 
    3435 
    … …  
    8990        @Override 
    9091        public Enum<C> getOutcomeCategoryByName(String categoryName) { 
     92                if (categoryName == null) { 
     93                        return null; 
     94                } 
    9195                EnumSet<C> categories = getOutcomeCategories(); 
    9296                for (Enum<C> c : categories) { 
    … …  
    9599                        } 
    96100                } 
     101 
     102                for (Enum<C> c : categories) { 
     103                        // check aliases 
     104                        Alias aliasAnnotation = ReflectionUtils.getAnnotation(c, Alias.class); 
     105                        if (aliasAnnotation != null) { 
     106                                String[] aliases = aliasAnnotation.value(); 
     107                                for (String alias : aliases) { 
     108                                        if (categoryName.equals(alias)) { 
     109                                                return c; 
     110                                        } 
     111                                } 
     112                        } 
     113                } 
     114 
    97115                return null; 
    98116        } 

  • AnalyzerBeans/trunk/core/src/main/java/org/eobjects/analyzer/util/ReflectionUtils.java

    r3049 r3053  
    479479                } 
    480480        } 
     481         
     482        public static <A extends Annotation> A getAnnotation(Enum<?> enumConstant, Class<A> annotationClass) { 
     483                try { 
     484                        Field field = enumConstant.getClass().getDeclaredField(enumConstant.name()); 
     485                        return getAnnotation(field, annotationClass); 
     486                } catch (Exception e) { 
     487                        throw new IllegalStateException(e); 
     488                } 
     489        } 
    481490 
    482491        public static <A extends Annotation> A getAnnotation(AnnotatedElement element, Class<A> annotationClass) { 
    … …  
    485494                } 
    486495        } 
     496         
     497        public static boolean isAnnotationPresent(Enum<?> enumConstant, Class<? extends Annotation> annotationClass) { 
     498                try { 
     499                        Field field = enumConstant.getClass().getDeclaredField(enumConstant.name()); 
     500                        return isAnnotationPresent(field, annotationClass); 
     501                } catch (Exception e) { 
     502                        throw new IllegalStateException(e); 
     503                } 
     504        } 
    487505 
    488506        public static boolean isAnnotationPresent(AnnotatedElement element, Class<? extends Annotation> annotationClass) { 

  • AnalyzerBeans/trunk/core/src/test/java/org/eobjects/analyzer/beans/filter/NullCheckFilterTest.java

    r2749 r3053  
    3030import org.eobjects.analyzer.descriptors.Descriptors; 
    3131import org.eobjects.analyzer.descriptors.FilterBeanDescriptor; 
     32import org.eobjects.analyzer.descriptors.SimpleDescriptorProvider; 
    3233import org.eobjects.analyzer.test.TestHelper; 
    3334import org.eobjects.analyzer.util.SchemaNavigator; 
    3435import org.eobjects.metamodel.query.Query; 
    3536 
    36 public class NotNullFilterTest extends TestCase { 
     37public class NullCheckFilterTest extends TestCase { 
     38 
     39        public void testAliases() throws Exception { 
     40                FilterBeanDescriptor<?, ?> desc1 = Descriptors.ofFilter(NullCheckFilter.class); 
     41 
     42                SimpleDescriptorProvider descriptorProvider = new SimpleDescriptorProvider(); 
     43                descriptorProvider.addFilterBeanDescriptor(desc1); 
     44 
     45                FilterBeanDescriptor<?, ?> desc2 = descriptorProvider.getFilterBeanDescriptorByDisplayName("Not null"); 
     46                FilterBeanDescriptor<?, ?> desc3 = descriptorProvider.getFilterBeanDescriptorByDisplayName("Null check"); 
     47 
     48                assertSame(desc1, desc2); 
     49                assertSame(desc1, desc3); 
     50 
     51                Enum<?> notNullOutcome1 = desc1.getOutcomeCategoryByName("VALID"); 
     52                Enum<?> notNullOutcome2 = desc1.getOutcomeCategoryByName("NOT_NULL"); 
     53                assertSame(notNullOutcome1, notNullOutcome2); 
     54 
     55                Enum<?> nullOutcome1 = desc1.getOutcomeCategoryByName("INVALID"); 
     56                Enum<?> nullOutcome2 = desc1.getOutcomeCategoryByName("NULL"); 
     57                assertSame(nullOutcome1, nullOutcome2); 
     58        } 
    3759 
    3860        public void testCategorize() throws Exception { 
    … …  
    4264                InputColumn<?>[] columns = new InputColumn[] { col1, col2, col3 }; 
    4365 
    44                 NotNullFilter filter = new NotNullFilter(columns, true); 
    45                 assertEquals(ValidationCategory.VALID, 
     66                NullCheckFilter filter = new NullCheckFilter(columns, true); 
     67                assertEquals(NullCheckFilter.NullCheckCategory.NOT_NULL, 
    4668                                filter.categorize(new MockInputRow().put(col1, 1).put(col2, true).put(col3, "foo"))); 
    4769 
    48                 assertEquals(ValidationCategory.INVALID, 
     70                assertEquals(NullCheckFilter.NullCheckCategory.NULL, 
    4971                                filter.categorize(new MockInputRow().put(col1, 1).put(col2, null).put(col3, "foo"))); 
    5072 
    51                 assertEquals(ValidationCategory.INVALID, 
     73                assertEquals(NullCheckFilter.NullCheckCategory.NULL, 
    5274                                filter.categorize(new MockInputRow().put(col1, 1).put(col2, true).put(col3, ""))); 
    5375 
    54                 assertEquals(ValidationCategory.INVALID, 
     76                assertEquals(NullCheckFilter.NullCheckCategory.NULL, 
    5577                                filter.categorize(new MockInputRow().put(col1, 1).put(col2, true).put(col3, null))); 
    5678 
    57                 assertEquals(ValidationCategory.INVALID, 
     79                assertEquals(NullCheckFilter.NullCheckCategory.NULL, 
    5880                                filter.categorize(new MockInputRow().put(col1, null).put(col2, null).put(col3, null))); 
    5981        } 
    6082 
    6183        public void testDescriptor() throws Exception { 
    62                 FilterBeanDescriptor<NotNullFilter, ValidationCategory> desc = Descriptors.ofFilter(NotNullFilter.class); 
    63                 Class<ValidationCategory> categoryEnum = desc.getOutcomeCategoryEnum(); 
    64                 assertEquals(ValidationCategory.class, categoryEnum); 
     84                FilterBeanDescriptor<NullCheckFilter, NullCheckFilter.NullCheckCategory> desc = Descriptors 
     85                                .ofFilter(NullCheckFilter.class); 
     86                Class<NullCheckFilter.NullCheckCategory> categoryEnum = desc.getOutcomeCategoryEnum(); 
     87                assertEquals(NullCheckFilter.NullCheckCategory.class, categoryEnum); 
    6588        } 
    6689 
    … …  
    7497                InputColumn<?>[] columns = new InputColumn[] { col1, col2 }; 
    7598 
    76                 NotNullFilter filter = new NotNullFilter(columns, true); 
     99                NullCheckFilter filter = new NullCheckFilter(columns, true); 
    77100 
    78101                Query baseQuery = con.getDataContext().query().from("EMPLOYEES").select("EMAIL").and("EMPLOYEENUMBER").toQuery(); 
    79                 Query optimizedQuery = filter.optimizeQuery(baseQuery.clone(), ValidationCategory.VALID); 
     102                Query optimizedQuery = filter.optimizeQuery(baseQuery.clone(), NullCheckFilter.NullCheckCategory.NOT_NULL); 
    80103 
    81104                assertEquals("SELECT \"EMPLOYEES\".\"EMAIL\", \"EMPLOYEES\".\"EMPLOYEENUMBER\" FROM " 
    … …  
    83106                                + "\"EMPLOYEES\".\"EMPLOYEENUMBER\" IS NOT NULL", optimizedQuery.toSql()); 
    84107 
    85                 optimizedQuery = filter.optimizeQuery(baseQuery.clone(), ValidationCategory.INVALID); 
     108                optimizedQuery = filter.optimizeQuery(baseQuery.clone(), NullCheckFilter.NullCheckCategory.NULL); 
    86109 
    87110                assertEquals("SELECT \"EMPLOYEES\".\"EMAIL\", \"EMPLOYEES\".\"EMPLOYEENUMBER\" FROM " 

  • AnalyzerBeans/trunk/core/src/test/java/org/eobjects/analyzer/descriptors/AnnotationBasedFilterDescriptorTest.java

    r2464 r3053  
    2525import junit.framework.TestCase; 
    2626 
    27 import org.eobjects.analyzer.beans.filter.NotNullFilter; 
    28 import org.eobjects.analyzer.beans.filter.ValidationCategory; 
     27import org.eobjects.analyzer.beans.filter.NullCheckFilter; 
    2928 
    3029public class AnnotationBasedFilterDescriptorTest extends TestCase { 
    3130 
    32         private FilterBeanDescriptor<NotNullFilter, ValidationCategory> desc = Descriptors.ofFilter(NotNullFilter.class); 
     31        private FilterBeanDescriptor<NullCheckFilter, NullCheckFilter.NullCheckCategory> desc = Descriptors.ofFilter(NullCheckFilter.class); 
    3332 
    3433        public void testGetCategoryEnum() throws Exception { 
    35                 Class<ValidationCategory> categoryEnum = desc.getOutcomeCategoryEnum(); 
     34                Class<NullCheckFilter.NullCheckCategory> categoryEnum = desc.getOutcomeCategoryEnum(); 
    3635 
    37                 assertEquals(ValidationCategory.class, categoryEnum); 
     36                assertEquals(NullCheckFilter.NullCheckCategory.class, categoryEnum); 
    3837        } 
    3938 
    … …  
    4140                Set<String> categoryNames = desc.getOutcomeCategoryNames(); 
    4241                categoryNames = new TreeSet<String>(categoryNames); 
    43                 assertEquals("[INVALID, VALID]", categoryNames.toString()); 
     42                assertEquals("[NOT_NULL, NULL]", categoryNames.toString()); 
    4443        } 
    4544} 

  • AnalyzerBeans/trunk/core/src/test/java/org/eobjects/analyzer/job/builder/AnalysisJobBuilderTest.java

    r3046 r3053  
    3434import org.eobjects.analyzer.beans.convert.ConvertToStringTransformer; 
    3535import org.eobjects.analyzer.beans.filter.MaxRowsFilter; 
    36 import org.eobjects.analyzer.beans.filter.NotNullFilter; 
     36import org.eobjects.analyzer.beans.filter.NullCheckFilter; 
     37import org.eobjects.analyzer.beans.filter.NullCheckFilter.NullCheckCategory; 
    3738import org.eobjects.analyzer.beans.filter.ValidationCategory; 
    3839import org.eobjects.analyzer.beans.standardize.EmailStandardizerTransformer; 
    … …  
    8182                analysisJobBuilder.addSourceColumns("PUBLIC.EMPLOYEES.REPORTSTO"); 
    8283                FilterJobBuilder<MaxRowsFilter, ValidationCategory> filter1 = analysisJobBuilder.addFilter(MaxRowsFilter.class); 
    83                 FilterJobBuilder<NotNullFilter, ValidationCategory> filter2 = analysisJobBuilder.addFilter(NotNullFilter.class); 
     84                FilterJobBuilder<NullCheckFilter, NullCheckFilter.NullCheckCategory> filter2 = analysisJobBuilder 
     85                                .addFilter(NullCheckFilter.class); 
    8486                filter2.addInputColumn(analysisJobBuilder.getSourceColumnByName("reportsto")); 
    85                 filter1.setRequirement(filter2.getOutcome(ValidationCategory.VALID)); 
     87                filter1.setRequirement(filter2.getOutcome(NullCheckCategory.NOT_NULL)); 
    8688 
    8789                try { 
    … …  
    195197                saAjb.addInputColumns(analysisJobBuilder.getSourceColumns()); 
    196198 
    197                 FilterJobBuilder<NotNullFilter, ValidationCategory> fjb = analysisJobBuilder.addFilter(NotNullFilter.class); 
     199                FilterJobBuilder<NullCheckFilter, NullCheckFilter.NullCheckCategory> fjb = analysisJobBuilder 
     200                                .addFilter(NullCheckFilter.class); 
    198201                fjb.addInputColumn(analysisJobBuilder.getSourceColumns().get(0)); 
    199202 
    … …  
    210213                assertEquals(result.get(1), pfAjb); 
    211214 
    212                 pfAjb.setRequirement(fjb, ValidationCategory.VALID); 
     215                pfAjb.setRequirement(fjb, NullCheckCategory.NOT_NULL); 
    213216 
    214217                result = analysisJobBuilder.getAvailableUnfilteredBeans(fjb); 
    … …  
    228231                assertSame(maxRowsFilter.getOutcome(ValidationCategory.VALID), emailStdTransformer.getRequirement()); 
    229232 
    230                 FilterJobBuilder<NotNullFilter, ValidationCategory> notNullFilter = analysisJobBuilder 
    231                                 .addFilter(NotNullFilter.class); 
     233                FilterJobBuilder<NullCheckFilter, NullCheckFilter.NullCheckCategory> notNullFilter = analysisJobBuilder 
     234                                .addFilter(NullCheckFilter.class); 
    232235                notNullFilter.setRequirement(null); 
    233                 maxRowsFilter.setRequirement(notNullFilter.getOutcome(ValidationCategory.VALID)); 
     236                maxRowsFilter.setRequirement(notNullFilter.getOutcome(NullCheckFilter.NullCheckCategory.NOT_NULL)); 
    234237 
    235238                assertNull(notNullFilter.getRequirement()); 
    … …  
    246249 
    247250                assertNull(analysisJobBuilder.getDefaultRequirement()); 
    248                 assertSame(notNullFilter.getOutcome(ValidationCategory.VALID), stringAnalyzer.getRequirement()); 
    249                 assertSame(notNullFilter.getOutcome(ValidationCategory.VALID), emailStdTransformer.getRequirement()); 
     251                assertSame(notNullFilter.getOutcome(NullCheckCategory.NOT_NULL), stringAnalyzer.getRequirement()); 
     252                assertSame(notNullFilter.getOutcome(NullCheckCategory.NOT_NULL), emailStdTransformer.getRequirement()); 
    250253 
    251254                con.close(); 

  • AnalyzerBeans/trunk/core/src/test/java/org/eobjects/analyzer/job/builder/MergedOutcomeJobBuilderTest.java

    r2631 r3053  
    2525 
    2626import org.eobjects.analyzer.beans.StringAnalyzer; 
    27 import org.eobjects.analyzer.beans.filter.NotNullFilter; 
     27import org.eobjects.analyzer.beans.filter.NullCheckFilter; 
    2828import org.eobjects.analyzer.beans.filter.SingleWordFilter; 
    2929import org.eobjects.analyzer.beans.filter.ValidationCategory; 
     30import org.eobjects.analyzer.beans.filter.NullCheckFilter.NullCheckCategory; 
    3031import org.eobjects.analyzer.beans.standardize.EmailStandardizerTransformer; 
    3132import org.eobjects.analyzer.beans.stringpattern.PatternFinderAnalyzer; 
    … …  
    5960                analysisJobBuilder.addSourceColumns("PUBLIC.EMPLOYEES.FIRSTNAME"); 
    6061 
    61                 FilterJobBuilder<NotNullFilter, ValidationCategory> fjb1 = analysisJobBuilder.addFilter(NotNullFilter.class); 
     62                FilterJobBuilder<NullCheckFilter, NullCheckFilter.NullCheckCategory> fjb1 = analysisJobBuilder 
     63                                .addFilter(NullCheckFilter.class); 
    6264                fjb1.addInputColumn(analysisJobBuilder.getSourceColumns().get(0)); 
    6365 
    … …  
    7476                } 
    7577 
    76                 mergedOutcomeJobBuilder.addMergedOutcome(fjb1, ValidationCategory.VALID); 
     78                mergedOutcomeJobBuilder.addMergedOutcome(fjb1, NullCheckFilter.NullCheckCategory.NOT_NULL); 
    7779 
    7880                try { 
    … …  
    9294                MergedOutcome outcome = mergedOutcomeJob.getOutcome(); 
    9395 
    94                 assertTrue(outcome.satisfiesRequirement(new ImmutableFilterOutcome(fjb1.toFilterJob(), ValidationCategory.VALID))); 
    95                 assertFalse(outcome.satisfiesRequirement(new ImmutableFilterOutcome(fjb1.toFilterJob(), ValidationCategory.INVALID))); 
     96                assertTrue(outcome.satisfiesRequirement(new ImmutableFilterOutcome(fjb1.toFilterJob(), NullCheckCategory.NOT_NULL))); 
     97                assertFalse(outcome.satisfiesRequirement(new ImmutableFilterOutcome(fjb1.toFilterJob(), NullCheckCategory.NULL))); 
    9698                assertTrue(outcome.satisfiesRequirement(new ImmutableFilterOutcome(fjb2.toFilterJob(), ValidationCategory.VALID))); 
    9799                assertFalse(outcome.satisfiesRequirement(new ImmutableFilterOutcome(fjb2.toFilterJob(), ValidationCategory.INVALID))); 
    98100 
    99                 AnalyzerJobBuilder<StringAnalyzer> ajb = analysisJobBuilder 
    100                                 .addAnalyzer(StringAnalyzer.class); 
     101                AnalyzerJobBuilder<StringAnalyzer> ajb = analysisJobBuilder.addAnalyzer(StringAnalyzer.class); 
    101102                ajb.setRequirement(outcome); 
    102103        } 
    … …  
    122123                assertNotNull(usernameCol); 
    123124 
    124                 FilterJobBuilder<NotNullFilter, ValidationCategory> f = ajb.addFilter(NotNullFilter.class); 
     125                FilterJobBuilder<NullCheckFilter, NullCheckFilter.NullCheckCategory> f = ajb.addFilter(NullCheckFilter.class); 
    125126                f.addInputColumn(usernameCol); 
    126127 
    127128                MergedOutcomeJobBuilder mojb = ajb.addMergedOutcomeJobBuilder(); 
    128                 mojb.addMergedOutcome(f, ValidationCategory.VALID).addInputColumn(usernameCol); 
    129                 mojb.addMergedOutcome(f, ValidationCategory.INVALID).addInputColumn(fnCol); 
     129                mojb.addMergedOutcome(f, NullCheckCategory.NOT_NULL).addInputColumn(usernameCol); 
     130                mojb.addMergedOutcome(f, NullCheckCategory.NULL).addInputColumn(fnCol); 
    130131 
    131132                MergedOutcomeJob mergedOutcomeJob = mojb.toMergedOutcomeJob(); 

  • AnalyzerBeans/trunk/core/src/test/java/org/eobjects/analyzer/job/runner/RowProcessingConsumerSorterTest.java

    r3014 r3053  
    3030import org.eobjects.analyzer.beans.StringAnalyzer; 
    3131import org.eobjects.analyzer.beans.convert.ConvertToStringTransformer; 
    32 import org.eobjects.analyzer.beans.filter.NotNullFilter; 
     32import org.eobjects.analyzer.beans.filter.NullCheckFilter; 
    3333import org.eobjects.analyzer.beans.filter.SingleWordFilter; 
    3434import org.eobjects.analyzer.beans.filter.ValidationCategory; 
     35import org.eobjects.analyzer.beans.filter.NullCheckFilter.NullCheckCategory; 
    3536import org.eobjects.analyzer.beans.mock.TransformerMock; 
    3637import org.eobjects.analyzer.beans.transform.WhitespaceTrimmerTransformer; 
    … …  
    7879 
    7980                // 1: add a not-null filter 
    80                 FilterJobBuilder<NotNullFilter, ValidationCategory> fjb1 = ajb.addFilter(NotNullFilter.class); 
     81                FilterJobBuilder<NullCheckFilter, NullCheckFilter.NullCheckCategory> fjb1 = ajb.addFilter(NullCheckFilter.class); 
    8182                fjb1.addInputColumn(inputColumn); 
    8283 
    … …  
    8485                TransformerJobBuilder<WhitespaceTrimmerTransformer> tjb1 = ajb.addTransformer(WhitespaceTrimmerTransformer.class); 
    8586                tjb1.addInputColumn(inputColumn); 
    86                 tjb1.setRequirement(fjb1, ValidationCategory.VALID); 
     87                tjb1.setRequirement(fjb1, NullCheckFilter.NullCheckCategory.NOT_NULL); 
    8788 
    8889                // 3: merge either the null or the trimmed value 
    8990                MergedOutcomeJobBuilder mojb = ajb.addMergedOutcomeJobBuilder(); 
    90                 mojb.addMergedOutcome(fjb1, ValidationCategory.VALID).addInputColumn(tjb1.getOutputColumns().get(0)); 
    91                 mojb.addMergedOutcome(fjb1, ValidationCategory.INVALID).addInputColumn(inputColumn); 
     91                mojb.addMergedOutcome(fjb1, NullCheckCategory.NOT_NULL).addInputColumn(tjb1.getOutputColumns().get(0)); 
     92                mojb.addMergedOutcome(fjb1, NullCheckCategory.NULL).addInputColumn(inputColumn); 
    9293                MutableInputColumn<?> mergedColumn1 = mojb.getOutputColumns().get(0); 
    9394 
    … …  
    107108                assertEquals(5, consumers.size()); 
    108109 
    109                 assertEquals("ImmutableFilterJob[name=null,filter=Not null]", consumers.get(0).getComponentJob().toString()); 
     110                assertEquals("ImmutableFilterJob[name=null,filter=Null check]", consumers.get(0).getComponentJob().toString()); 
    110111                assertEquals("ImmutableTransformerJob[name=null,transformer=Whitespace trimmer]", consumers.get(1).getComponentJob() 
    111112                                .toString()); 
    112113                assertEquals( 
    113                                 "ImmutableMergedOutcomeJob[name=null,mergeInputs=[ImmutableMergeInput[FilterOutcome[category=VALID]], ImmutableMergeInput[FilterOutcome[category=INVALID]]]]", 
     114                                "ImmutableMergedOutcomeJob[name=null,mergeInputs=[ImmutableMergeInput[FilterOutcome[category=NOT_NULL]], ImmutableMergeInput[FilterOutcome[category=NULL]]]]", 
    114115                                consumers.get(2).getComponentJob().toString()); 
    115116                assertEquals("ImmutableFilterJob[name=null,filter=Single word]", consumers.get(3).getComponentJob().toString()); 
    … …  
    125126 
    126127                // 1: add a not-null filter 
    127                 FilterJobBuilder<NotNullFilter, ValidationCategory> fjb1 = ajb.addFilter(NotNullFilter.class); 
     128                FilterJobBuilder<NullCheckFilter, NullCheckFilter.NullCheckCategory> fjb1 = ajb.addFilter(NullCheckFilter.class); 
    128129                fjb1.addInputColumn(inputColumn); 
    129130 
    … …  
    131132                TransformerJobBuilder<WhitespaceTrimmerTransformer> tjb1 = ajb.addTransformer(WhitespaceTrimmerTransformer.class); 
    132133                tjb1.addInputColumn(inputColumn); 
    133                 tjb1.setRequirement(fjb1, ValidationCategory.VALID); 
     134                tjb1.setRequirement(fjb1, NullCheckCategory.NOT_NULL); 
    134135 
    135136                // 3: trim again, just to examplify (depends on first trim output) 
    … …  
    155156                consumers = new RowProcessingConsumerSorter(consumers).createProcessOrderedConsumerList(); 
    156157 
    157                 assertEquals("ImmutableFilterJob[name=null,filter=Not null]", consumers.get(0).getComponentJob().toString()); 
     158                assertEquals("ImmutableFilterJob[name=null,filter=Null check]", consumers.get(0).getComponentJob().toString()); 
    158159                assertEquals("ImmutableTransformerJob[name=null,transformer=Whitespace trimmer]", consumers.get(1).getComponentJob() 
    159160                                .toString()); 

  • AnalyzerBeans/trunk/core/src/test/java/org/eobjects/analyzer/job/runner/RowProcessingMetricsImplTest.java

    r3043 r3053  
    2727import org.eobjects.analyzer.beans.filter.EqualsFilter; 
    2828import org.eobjects.analyzer.beans.filter.MaxRowsFilter; 
    29 import org.eobjects.analyzer.beans.filter.NotNullFilter; 
     29import org.eobjects.analyzer.beans.filter.NullCheckFilter; 
    3030import org.eobjects.analyzer.beans.filter.ValidationCategory; 
    3131import org.eobjects.analyzer.configuration.AnalyzerBeansConfiguration; 
    … …  
    104104 
    105105                // there's 1 record which has a reportsto value of null. 
    106                 FilterJobBuilder<NotNullFilter, ValidationCategory> filter2 = ajb.addFilter(NotNullFilter.class); 
     106                FilterJobBuilder<NullCheckFilter, NullCheckFilter.NullCheckCategory> filter2 = ajb.addFilter(NullCheckFilter.class); 
    107107                ajb.addSourceColumns("PUBLIC.EMPLOYEES.REPORTSTO"); 
    108108                filter2.addInputColumn(ajb.getSourceColumnByName("reportsto")); 
    … …  
    110110                filter2.setRequirement(filter1.getOutcome(ValidationCategory.INVALID)); 
    111111 
    112                 ajb.getAnalyzerJobBuilders().get(0).setRequirement(filter2.getOutcome(ValidationCategory.VALID)); 
     112                ajb.getAnalyzerJobBuilders().get(0).setRequirement(filter2.getOutcome(NullCheckFilter.NullCheckCategory.NOT_NULL)); 
    113113 
    114114                job = ajb.toAnalysisJob(); 

  • AnalyzerBeans/trunk/core/src/test/java/org/eobjects/analyzer/job/runner/RowProcessingQueryOptimizerTest.java

    r3014 r3053  
    3030import org.eobjects.analyzer.beans.api.Transformer; 
    3131import org.eobjects.analyzer.beans.filter.MaxRowsFilter; 
    32 import org.eobjects.analyzer.beans.filter.NotNullFilter; 
     32import org.eobjects.analyzer.beans.filter.NullCheckFilter; 
     33import org.eobjects.analyzer.beans.filter.NullCheckFilter.NullCheckCategory; 
    3334import org.eobjects.analyzer.beans.filter.ValidationCategory; 
    3435import org.eobjects.analyzer.beans.standardize.EmailStandardizerTransformer; 
    … …  
    122123                assertTrue(optimizer.isOptimizable()); 
    123124 
    124                 FilterJobBuilder<?, ?> fjb = ajb.addFilter(NotNullFilter.class).addInputColumn(lastNameInputColumn); 
    125                 maxRowsBuilder.setRequirement(fjb, ValidationCategory.VALID); 
     125                FilterJobBuilder<?, ?> fjb = ajb.addFilter(NullCheckFilter.class).addInputColumn(lastNameInputColumn); 
     126                maxRowsBuilder.setRequirement(fjb, NullCheckCategory.NOT_NULL); 
    126127                consumers.add(0, createConsumer(fjb)); 
    127128 
    … …  
    182183 
    183184        public void testMultipleOptimizations() throws Exception { 
    184                 FilterJobBuilder<NotNullFilter, ValidationCategory> notNullBuilder = ajb.addFilter(NotNullFilter.class); 
     185                FilterJobBuilder<NullCheckFilter, NullCheckFilter.NullCheckCategory> notNullBuilder = ajb.addFilter(NullCheckFilter.class); 
    185186                Column emailColumn = con.getSchemaNavigator().convertToColumn("EMPLOYEES.EMAIL"); 
    186187                ajb.addSourceColumn(emailColumn); 
    … …  
    188189                notNullBuilder.addInputColumn(emailInputColumn); 
    189190                notNullBuilder.setRequirement(maxRowsBuilder, ValidationCategory.VALID); 
    190                 stringAnalyzerBuilder.setRequirement(notNullBuilder, ValidationCategory.VALID); 
     191                stringAnalyzerBuilder.setRequirement(notNullBuilder, NullCheckCategory.NOT_NULL); 
    191192 
    192193                consumers.remove(1); 

  • AnalyzerBeans/trunk/core/src/test/java/org/eobjects/analyzer/job/tasks/ConsumeRowTaskTest.java

    r2647 r3053  
    2525 
    2626import org.eobjects.analyzer.beans.convert.ConvertToNumberTransformer; 
    27 import org.eobjects.analyzer.beans.filter.NotNullFilter; 
    28 import org.eobjects.analyzer.beans.filter.ValidationCategory; 
     27import org.eobjects.analyzer.beans.filter.NullCheckFilter; 
    2928import org.eobjects.analyzer.configuration.AnalyzerBeansConfiguration; 
    3029import org.eobjects.analyzer.configuration.AnalyzerBeansConfigurationImpl; 
    … …  
    121120                        builder.setDatastore(new CsvDatastore("Names", "src/test/resources/example-name-lengths.csv")); 
    122121                        builder.addSourceColumns("name"); 
    123                         FilterJobBuilder<NotNullFilter, ValidationCategory> filterJobBuilder = builder.addFilter( 
    124                                         NotNullFilter.class); 
     122                        FilterJobBuilder<NullCheckFilter, NullCheckFilter.NullCheckCategory> filterJobBuilder = builder.addFilter( 
     123                                        NullCheckFilter.class); 
    125124                        filterJobBuilder.addInputColumn(builder.getSourceColumnByName("name")); 
    126125                        filterJobBuilder.setConfiguredProperty("Consider empty string as null", true); 
    … …  
    130129                        MutableInputColumn<?> numberColumn = convertTransformer.getOutputColumns().get(0); 
    131130 
    132                         convertTransformer.setRequirement(filterJobBuilder, ValidationCategory.VALID); 
     131                        convertTransformer.setRequirement(filterJobBuilder, NullCheckFilter.NullCheckCategory.NOT_NULL); 
    133132                        builder.addAnalyzer(MockAnalyzer.class).addInputColumns(numberColumn); 
    134133                        job = builder.toAnalysisJob(); 

  • AnalyzerBeans/trunk/env/xml-config/src/test/java/org/eobjects/analyzer/job/JaxbJobWriterTest.java

    r2749 r3053  
    3434import org.eobjects.analyzer.beans.DateGapAnalyzer; 
    3535import org.eobjects.analyzer.beans.StringAnalyzer; 
    36 import org.eobjects.analyzer.beans.filter.NotNullFilter; 
     36import org.eobjects.analyzer.beans.filter.NullCheckFilter; 
     37import org.eobjects.analyzer.beans.filter.NullCheckFilter.NullCheckCategory; 
    3738import org.eobjects.analyzer.beans.filter.SingleWordFilter; 
    3839import org.eobjects.analyzer.beans.filter.ValidationCategory; 
    … …  
    245246                                "JaxbJobWriterTest-file2.xml"); 
    246247 
    247                 FilterJobBuilder<NotNullFilter, ValidationCategory> fjb1 = ajb 
    248                                 .addFilter(NotNullFilter.class); 
     248                FilterJobBuilder<NullCheckFilter, NullCheckFilter.NullCheckCategory> fjb1 = ajb 
     249                                .addFilter(NullCheckFilter.class); 
    249250                fjb1.addInputColumn(fnCol); 
    250                 strAnalyzer.setRequirement(fjb1, "VALID"); 
     251                strAnalyzer.setRequirement(fjb1, "NOT_NULL"); 
    251252 
    252253                assertMatchesBenchmark(ajb.toAnalysisJob(), 
    … …  
    270271                MergedOutcomeJobBuilder mergedOutcome = ajb 
    271272                                .addMergedOutcomeJobBuilder(); 
    272                 mergedOutcome.addMergedOutcome(fjb1, ValidationCategory.INVALID) 
     273                mergedOutcome.addMergedOutcome(fjb1, NullCheckCategory.NULL) 
    273274                                .addInputColumn(fnCol); 
    274275                mergedOutcome.addMergedOutcome(fjb2, ValidationCategory.INVALID) 

  • AnalyzerBeans/trunk/env/xml-config/src/test/resources/JaxbJobWriterTest-file3.xml

    r2568 r3053  
    2323        </transformer> 
    2424        <filter> 
    25             <descriptor ref="Not null"/> 
     25            <descriptor ref="Null check"/> 
    2626            <properties> 
    2727                <property value="false" name="Consider empty string as null"/> 
    2828            </properties> 
    2929            <input ref="col_0"/> 
    30             <outcome id="outcome_0" category="VALID"/> 
     30            <outcome id="outcome_0" category="NOT_NULL"/> 
    3131        </filter> 
    3232    </transformation> 

  • AnalyzerBeans/trunk/env/xml-config/src/test/resources/JaxbJobWriterTest-file4.xml

    r2568 r3053  
    2323        </transformer> 
    2424        <filter> 
    25             <descriptor ref="Not null"/> 
     25            <descriptor ref="Null check"/> 
    2626            <properties> 
    2727                <property value="false" name="Consider empty string as null"/> 
    2828            </properties> 
    2929            <input ref="col_0"/> 
    30             <outcome id="outcome_0" category="VALID"/> 
     30            <outcome id="outcome_0" category="NOT_NULL"/> 
    3131        </filter> 
    3232    </transformation> 

  • AnalyzerBeans/trunk/env/xml-config/src/test/resources/JaxbJobWriterTest-file5.xml

    r2568 r3053  
    2323        </transformer> 
    2424        <filter> 
    25             <descriptor ref="Not null"/> 
     25            <descriptor ref="Null check"/> 
    2626            <properties> 
    2727                <property value="false" name="Consider empty string as null"/> 
    2828            </properties> 
    2929            <input ref="col_0"/> 
    30             <outcome id="outcome_3" category="VALID"/> 
    31             <outcome id="outcome_0" category="INVALID"/> 
     30            <outcome id="outcome_0" category="NULL"/> 
     31            <outcome id="outcome_3" category="NOT_NULL"/> 
    3232        </filter> 
    3333        <filter> 

  • AnalyzerBeans/trunk/env/xml-config/src/test/resources/JaxbJobWriterTest-file6.xml

    r2568 r3053  
    2323        </transformer> 
    2424        <filter name="fjb1"> 
    25             <descriptor ref="Not null"/> 
     25            <descriptor ref="Null check"/> 
    2626            <properties> 
    2727                <property value="false" name="Consider empty string as null"/> 
    2828            </properties> 
    2929            <input ref="col_0"/> 
    30             <outcome id="outcome_3" category="VALID"/> 
    31             <outcome id="outcome_0" category="INVALID"/> 
     30            <outcome id="outcome_0" category="NULL"/> 
     31            <outcome id="outcome_3" category="NOT_NULL"/> 
    3232        </filter> 
    3333        <filter name="fjb2"> 
Note: See TracChangeset for help on using the changeset viewer.