Java Domain.addLogicalModel方法代码示例

import org.pentaho.metadata.model.Domain; //导入方法依赖的package包/类
@Test
public void serializeIntoDomain() {
  KettleModelerSource source = new KettleModelerSource();
  source.setFilename("filename");
  source.setMetaId("metaId");
  source.setRepositoryName("repositoryName");

  Domain domain = new Domain();
  LogicalModel lm = new LogicalModel();

  domain.addLogicalModel(lm);

  source.serializeIntoDomain(domain);

  assertEquals(source.getSourceType(), lm.getProperty(source.getSourceTypePropertyName()));
  assertEquals(source.getFilename(), lm.getProperty(source.getFilenamePropertyName()));
  assertEquals(source.getMetaId(), lm.getProperty(source.getMetaIdPropertyName()));
  assertEquals(source.getRepositoryName(), lm.getProperty(source.getRepositoryNamePropertyName()));
}
 

import org.pentaho.metadata.model.Domain; //导入方法依赖的package包/类
@Test
public void initialize() throws ModelerException {
  KettleModelerSource source = new KettleModelerSource();

  String tableName = "tableName";
  String schemaName = "schemaName";
  String fileName = "fileName";
  String repositoryName = "repositoryName";
  String metaId = "metaId";

  SqlPhysicalTable table = new SqlPhysicalTable();
  SqlDataSource dataSource = new SqlDataSource();
  dataSource.setHostname("hostname");

  SqlPhysicalModel model = new SqlPhysicalModel();
  model.setDatasource(dataSource);
  model.addPhysicalTable(table);

  LogicalModel lm = new LogicalModel();

  Domain domain = new Domain();
  domain.addPhysicalModel(model);
  domain.addLogicalModel(lm);

  // Set the properties KettleModelerSource will look for when extracting values
  lm.setProperty(source.getFilenamePropertyName(), fileName );
  lm.setProperty(source.getRepositoryNamePropertyName(), repositoryName );
  lm.setProperty(source.getMetaIdPropertyName(), metaId );
  table.setProperty("target_table", tableName );
  table.setProperty("target_schema", schemaName );

  source.initialize(domain);

  assertEquals(tableName, source.getTableName());
  assertEquals(schemaName, source.getSchemaName());
  assertEquals(repositoryName, source.getRepositoryName());
  assertEquals(metaId , source.getMetaId());
}
 

import org.pentaho.metadata.model.Domain; //导入方法依赖的package包/类
@Before
public void init() throws Exception {
  helper = new QueryXmlHelper();
  Domain domain = TestHelper.getBasicDomain();
  LogicalModel model = TestHelper.buildDefaultModel();
  domain.addLogicalModel( model );
  model.setId( "MODEL1" );
  query = new Query( domain, model );

  LogicalColumn column = new LogicalColumn();
  column.setId( "LC_Test_Column1" );
  LogicalColumn column2 = new LogicalColumn();
  column2.setId( "LC_Test_Column2" );
  Category category = new Category();
  category.getLogicalColumns().add( column );
  query.getLogicalModel().getCategories().add( category );

  LogicalTable lt = new LogicalTable();
  lt.getLogicalColumns().add( column );
  lt.getLogicalColumns().add( column2 );
  query.getLogicalModel().getLogicalTables().add( lt );

  documentBuilderFactory = DocumentBuilderFactory.newInstance();
  db = documentBuilderFactory.newDocumentBuilder();
  doc = db.newDocument();
  metadataDomainRepository = new InMemoryMetadataDomainRepository();
  metadataDomainRepository.storeDomain( domain, true );
}
 

import org.pentaho.metadata.model.Domain; //导入方法依赖的package包/类
@Test
public void testFromXML() throws Exception {
  Domain domain = TestHelper.getBasicDomain();
  LogicalModel model = TestHelper.buildDefaultModel();
  domain.addLogicalModel( model );
  model.setId( "MODEL2" );
  Query query = new Query( domain, model );
  String xml = helper.toXML( query );
  try {
    query = helper.fromXML( metadataDomainRepository, xml );
    fail();
  } catch ( PentahoMetadataException e ) {
    // expected
  }
}
 

import org.pentaho.metadata.model.Domain; //导入方法依赖的package包/类
@Before
public void setup() {

  String locale = LocaleHelper.getLocale().toString();

  SqlPhysicalModel model = new SqlPhysicalModel();
  SqlDataSource dataSource = new SqlDataSource();
  dataSource.setDatabaseName( "SampleData" );
  model.setDatasource( dataSource );
  SqlPhysicalTable table = new SqlPhysicalTable( model );
  model.getPhysicalTables().add( table );
  table.setTargetTableType( TargetTableType.INLINE_SQL );
  table.setTargetTable( "select * from customers" );
  table.setId( "customers" );

  SqlPhysicalColumn column = new SqlPhysicalColumn( table );
  column.setTargetColumn( "customername" );
  column.setName( new LocalizedString( locale, "Customer Name" ) );
  column.setDescription( new LocalizedString( locale, "Customer Name Desc" ) );
  column.setDataType( DataType.STRING );
  column.setId( "cutomer_customername" );

  table.getPhysicalColumns().add( column );

  LogicalModel logicalModel = new LogicalModel();
  model.setId( "MODEL" );
  model.setName( new LocalizedString( locale, "My Model" ) );
  model.setDescription( new LocalizedString( locale, "A Description of the Model" ) );

  LogicalTable logicalTable = new LogicalTable();
  logicalTable.setId( "BT_CUSTOMERS" );
  logicalTable.setPhysicalTable( table );

  logicalModel.getLogicalTables().add( logicalTable );
  logicalModel.setName( new LocalizedString( locale, "My Model" ) );

  logicalColumn1 = new LogicalColumn();
  logicalColumn1.setId( "LC_CUSTOMERNAME" );
  logicalColumn1.setPhysicalColumn( column );
  logicalColumn1.setAggregationType( AggregationType.COUNT );
  logicalColumn1.setLogicalTable( logicalTable );
  logicalColumn1.setDataType( DataType.STRING );

  logicalColumn2 = new LogicalColumn();
  logicalColumn2.setId( "LC_CUSTOMERNUMBER" );
  logicalColumn2.setAggregationType( AggregationType.COUNT );
  logicalColumn2.setPhysicalColumn( column );
  logicalColumn2.setLogicalTable( logicalTable );
  logicalColumn2.setDataType( DataType.NUMERIC );


  logicalTable.addLogicalColumn( logicalColumn1 );
  logicalTable.addLogicalColumn( logicalColumn2 );


  domain = new Domain();
  domain.addPhysicalModel( model );
  domain.addLogicalModel( logicalModel );

  physicalColumn = column;

  SqlPhysicalColumn column2 = new SqlPhysicalColumn( table );
  column2.setTargetColumn( "customername" );
  column2.setName( new LocalizedString( locale, "Customer Number" ) );
  column2.setDescription( new LocalizedString( locale, "Customer Number" ) );
  column2.setDataType( DataType.NUMERIC );
  column2.setId( "customer_customernumber" );

  physicalColumn2 = column2;

  table.getPhysicalColumns().add( physicalColumn2 );
}
 

import org.pentaho.metadata.model.Domain; //导入方法依赖的package包/类
public Domain generateDomain( final ImportStrategy importStrategy ) throws PentahoMetadataException {
  Domain domain = new Domain();
  domain.setId( modelName );

  List<LocaleType> locales = new ArrayList<LocaleType>();
  locales.add( new LocaleType( "en_US", "English (US)" ) ); //$NON-NLS-1$ //$NON-NLS-2$
  domain.setLocales( locales );

  SqlPhysicalModel physicalModel = new SqlPhysicalModel();
  physicalModel.setId( databaseMeta.getName() );
  physicalModel.setDatasource( ThinModelConverter.convertFromLegacy( databaseMeta ) );

  Database database = database();

  try {
    // Add the database connection to the empty schema...
    //
    domain.addPhysicalModel( physicalModel );

    // Also add a model with the same name as the model name...
    //
    String bmID = Util.getLogicalModelIdPrefix() + "_" + modelName.replaceAll( " ", "_" ).toUpperCase(); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
    LogicalModel logicalModel = new LogicalModel();
    logicalModel.setId( bmID );
    domain.addLogicalModel( logicalModel );

    // Connect to the database...
    //
    database.connect();

    // clear the cache
    DBCache.getInstance().clear( databaseMeta.getName() );

    for ( int i = 0; i < tableNames.length; i++ ) {
      SchemaTable schemaTable = tableNames[i];

      // Import the specified tables and turn them into PhysicalTable
      // objects...
      //
      SqlPhysicalTable physicalTable =
          PhysicalTableImporter.importTableDefinition( database, schemaTable.getSchemaName(), schemaTable
          .getTableName(), locale, importStrategy );
      physicalModel.addPhysicalTable( physicalTable );

      // At the same time, we will create a business table and add that to the
      // business model...
      //
      LogicalTable businessTable = createBusinessTable( physicalTable, locale );
      logicalModel.addLogicalTable( businessTable );
    }
  } catch ( Exception e ) {
    // For the unexpected stuff, just throw the exception upstairs.
    //
    throw new PentahoMetadataException( e );
  } finally {
    // Make sure to close the connection
    //
    database.disconnect();
  }

  return domain;
}
 

import org.pentaho.metadata.model.Domain; //导入方法依赖的package包/类
@Test
public void testSerializeSqlPhysicalModel() {

  String locale = LocaleHelper.getLocale().toString();

  SqlPhysicalModel model = new SqlPhysicalModel();
  SqlDataSource dataSource = new SqlDataSource();
  dataSource.setDatabaseName( "SampleData" );
  model.setDatasource( dataSource );
  SqlPhysicalTable table = new SqlPhysicalTable( model );
  model.getPhysicalTables().add( table );
  table.setTargetTableType( TargetTableType.INLINE_SQL );
  table.setTargetTable( "select * from customers" );

  SqlPhysicalColumn column = new SqlPhysicalColumn( table );
  column.setTargetColumn( "customername" );
  column.setName( new LocalizedString( locale, "Customer Name" ) );
  column.setDescription( new LocalizedString( locale, "Customer Name Desc" ) );
  column.setDataType( DataType.STRING );

  table.getPhysicalColumns().add( column );

  LogicalModel logicalModel = new LogicalModel();
  model.setId( "MODEL" );
  model.setName( new LocalizedString( locale, "My Model" ) );
  model.setDescription( new LocalizedString( locale, "A Description of the Model" ) );

  LogicalTable logicalTable = new LogicalTable();
  logicalTable.setPhysicalTable( table );

  logicalModel.getLogicalTables().add( logicalTable );

  LogicalColumn logicalColumn = new LogicalColumn();
  logicalColumn.setId( "LC_CUSTOMERNAME" );
  logicalColumn.setPhysicalColumn( column );

  logicalTable.addLogicalColumn( logicalColumn );

  Category mainCategory = new Category();
  mainCategory.setId( "CATEGORY" );
  mainCategory.setName( new LocalizedString( locale, "Category" ) );
  mainCategory.addLogicalColumn( logicalColumn );

  logicalModel.getCategories().add( mainCategory );

  Domain domain = new Domain();
  domain.addPhysicalModel( model );
  domain.addLogicalModel( logicalModel );

  // basic tests
  SerializationService service = new SerializationService();

  String xml = service.serializeDomain( domain );

  // System.out.println(xml);

  Domain domain2 = service.deserializeDomain( xml );

  Assert.assertEquals( 1, domain2.getPhysicalModels().size() );
  SqlPhysicalModel model2 = (SqlPhysicalModel) domain2.getPhysicalModels().get( 0 );
  Assert.assertEquals( "SampleData", model2.getDatasource().getDatabaseName() );
  Assert.assertEquals( 1, model.getPhysicalTables().size() );
  Assert.assertEquals( TargetTableType.INLINE_SQL, model.getPhysicalTables().get( 0 ).getTargetTableType() );

  Assert.assertEquals( 1, domain.getLogicalModels().size() );
  Assert.assertEquals( 1, domain.getLogicalModels().get( 0 ).getCategories().size() );
  Assert.assertEquals( 1, domain.getLogicalModels().get( 0 ).getCategories().get( 0 ).getLogicalColumns().size() );
  Assert.assertEquals( domain.getLogicalModels().get( 0 ).getLogicalTables().get( 0 ).getLogicalColumns().get( 0 ),
      domain.getLogicalModels().get( 0 ).getCategories().get( 0 ).getLogicalColumns().get( 0 ) );
  Assert.assertEquals( "Customer Name", domain.getLogicalModels().get( 0 ).getCategories().get( 0 )
      .getLogicalColumns().get( 0 ).getName().getString( "en_US" ) );
  Assert.assertEquals( "Customer Name Desc", domain.getLogicalModels().get( 0 ).getCategories().get( 0 )
      .getLogicalColumns().get( 0 ).getDescription().getString( "en_US" ) );

}
 

import org.pentaho.metadata.model.Domain; //导入方法依赖的package包/类
public static Domain getBasicDomain() {

    String locale = LocaleHelper.getLocale().toString();

    SqlPhysicalModel model = new SqlPhysicalModel();
    SqlDataSource dataSource = new SqlDataSource();
    dataSource.setDatabaseName( "SampleData" );
    model.setDatasource( dataSource );
    SqlPhysicalTable table = new SqlPhysicalTable( model );
    table.setId( "PT1" );
    model.getPhysicalTables().add( table );
    table.setTargetTableType( TargetTableType.INLINE_SQL );
    table.setTargetTable( "select * from customers" );

    SqlPhysicalColumn column = new SqlPhysicalColumn( table );
    column.setId( "PC1" );
    column.setTargetColumn( "customername" );
    column.setName( new LocalizedString( locale, "Customer Name" ) );
    column.setDescription( new LocalizedString( locale, "Customer Name Desc" ) );
    column.setDataType( DataType.STRING );
    table.getPhysicalColumns().add( column );

    LogicalModel logicalModel = new LogicalModel();
    logicalModel.setId( "MODEL" );
    logicalModel.setName( new LocalizedString( locale, "My Model" ) );
    logicalModel.setDescription( new LocalizedString( locale, "A Description of the Model" ) );

    LogicalTable logicalTable = new LogicalTable();
    logicalTable.setId( "LT" );
    logicalTable.setPhysicalTable( table );
    logicalTable.setLogicalModel( logicalModel );

    logicalModel.getLogicalTables().add( logicalTable );

    LogicalColumn logicalColumn = new LogicalColumn();
    logicalColumn.setId( "LC_CUSTOMERNAME" );
    logicalColumn.setPhysicalColumn( column );
    logicalColumn.setLogicalTable( logicalTable );
    logicalTable.addLogicalColumn( logicalColumn );

    Category mainCategory = new Category( logicalModel );
    mainCategory.setId( "CATEGORY" );
    mainCategory.setName( new LocalizedString( locale, "Category" ) );
    mainCategory.addLogicalColumn( logicalColumn );

    logicalModel.getCategories().add( mainCategory );

    Domain domain = new Domain();
    domain.setId( "DOMAIN" );
    domain.addPhysicalModel( model );
    domain.addLogicalModel( logicalModel );

    return domain;
  }
 

import org.pentaho.metadata.model.Domain; //导入方法依赖的package包/类
@Test
public void testFileBasedRepository() throws Exception {

  File file = new File( "target/test/DOMAIN.domain.xml" );

  if ( file.exists() ) {
    file.delete();
  }

  Assert.assertTrue( !file.exists() );

  Domain domain = TestHelper.getBasicDomain();
  LogicalModel model2 = (LogicalModel) domain.getLogicalModels().get( 0 ).clone();
  model2.setId( "MODEL2" );

  FileBasedMetadataDomainRepository repo = new FileBasedMetadataDomainRepository();
  repo.setDomainFolder( "target/test" );
  repo.storeDomain( domain, false );

  Assert.assertTrue( file.exists() );
  long fileSize = file.length();

  domain.addLogicalModel( model2 );

  try {
    repo.storeDomain( domain, false );
    Assert.fail();
  } catch ( Exception e ) {
    Assert.assertTrue( e instanceof DomainAlreadyExistsException );
  }

  repo.storeDomain( domain, true );

  long newFileSize = file.length();

  Assert.assertNotSame( fileSize, newFileSize );

  Domain domain2 = repo.getDomain( domain.getId() );
  Assert.assertEquals( 2, domain2.getLogicalModels().size() );

  repo.removeModel( domain.getId(), "MODEL" );

  long fileSize3 = file.length();

  Assert.assertNotSame( newFileSize, fileSize3 );

  Domain domain3 = repo.getDomain( domain.getId() );

  Assert.assertEquals( 1, domain3.getLogicalModels().size() );

  repo.removeModel( domain.getId(), "MODEL2" );

  Assert.assertTrue( !file.exists() );

  Domain nullDomain = repo.getDomain( domain.getId() );

  Assert.assertNull( nullDomain );

}