示例#1
0
  @Test
  public void testFKAccrossSchemas() throws Exception {
    String ddl = "CREATE FOREIGN TABLE G1(g1e1 integer, g1e2 varchar, PRIMARY KEY(g1e1, g1e2));\n";

    String ddl2 =
        "CREATE FOREIGN TABLE G2( g2e1 integer, g2e2 varchar, PRIMARY KEY(g2e1, g2e2),"
            + "FOREIGN KEY (g2e1, g2e2) REFERENCES model.G1)";

    MetadataFactory f1 = helpParse(ddl, "model");
    MetadataFactory f2 = helpParse(ddl2, "model2");

    VDBMetaData vdb = new VDBMetaData();
    vdb.setName("myVDB"); // $NON-NLS-1$
    ModelMetaData modelOne = new ModelMetaData();
    modelOne.setName("model"); // $NON-NLS-1$
    vdb.addModel(modelOne);

    ModelMetaData modelTwo = new ModelMetaData();
    modelTwo.setName("model2"); // $NON-NLS-1$
    vdb.addModel(modelTwo);

    MetadataStore s = f1.asMetadataStore();
    f2.mergeInto(s);

    ValidatorReport report = new MetadataValidator().validate(vdb, s);

    assertFalse(report.hasItems());

    Table table = s.getSchema("model2").getTable("G2");
    ForeignKey fk = table.getForeignKeys().get(0);
    assertEquals(fk.getColumns(), table.getColumns());
    assertEquals("G1", fk.getReferenceTableName());

    assertEquals(fk.getPrimaryKey().getColumns(), s.getSchema("model").getTable("G1").getColumns());
  }
示例#2
0
  @Test
  public void testOptionalFKFail() throws Exception {
    String ddl =
        "CREATE FOREIGN TABLE G1(g1e1 integer, g1e2 varchar);\n"
            + "CREATE FOREIGN TABLE G2( g2e1 integer, g2e2 varchar, PRIMARY KEY(g2e1, g2e2),"
            + "FOREIGN KEY (g2e1, g2e2) REFERENCES G1)";

    MetadataFactory s = helpParse(ddl, "model");
    Map<String, Table> tableMap = s.getSchema().getTables();
    assertEquals(2, tableMap.size());

    assertTrue("Table not found", tableMap.containsKey("G1"));
    assertTrue("Table not found", tableMap.containsKey("G2"));

    Table table = tableMap.get("G2");
    ForeignKey fk = table.getForeignKeys().get(0);
    assertEquals(fk.getColumns(), table.getColumns());
    assertEquals("G1", fk.getReferenceTableName());

    VDBMetaData vdb = new VDBMetaData();
    vdb.setName("myVDB"); // $NON-NLS-1$
    ModelMetaData modelOne = new ModelMetaData();
    modelOne.setName("model"); // $NON-NLS-1$
    vdb.addModel(modelOne);

    ValidatorReport report = new MetadataValidator().validate(vdb, s.asMetadataStore());

    assertTrue(report.hasItems());
  }
 private Command aliasCommand(AccessNode aNode, Command command, Object modelID)
     throws TeiidComponentException, QueryPlannerException {
   try {
     command = (Command) command.clone();
     boolean aliasGroups =
         modelID != null
             && (CapabilitiesUtil.supportsGroupAliases(modelID, metadata, capFinder)
                 || CapabilitiesUtil.supports(
                     Capability.QUERY_FROM_INLINE_VIEWS, modelID, metadata, capFinder));
     boolean aliasColumns =
         modelID != null
             && (CapabilitiesUtil.supports(
                     Capability.QUERY_SELECT_EXPRESSION, modelID, metadata, capFinder)
                 || CapabilitiesUtil.supports(
                     Capability.QUERY_FROM_INLINE_VIEWS, modelID, metadata, capFinder));
     AliasGenerator visitor = new AliasGenerator(aliasGroups, !aliasColumns);
     SourceHint sh = command.getSourceHint();
     if (sh != null && aliasGroups) {
       VDBMetaData vdb = context.getDQPWorkContext().getVDB();
       ModelMetaData model = vdb.getModel(aNode.getModelName());
       List<String> sourceNames = model.getSourceNames();
       SpecificHint sp = null;
       if (sourceNames.size() == 1) {
         sp = sh.getSpecificHint(sourceNames.get(0));
       }
       if (sh.isUseAliases() || (sp != null && sp.isUseAliases())) {
         visitor.setAliasMapping(context.getAliasMapping());
       }
     }
     List<Reference> references = ReferenceCollectorVisitor.getReferences(command);
     if (!references.isEmpty()) {
       Set<String> correleatedGroups = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
       for (Reference ref : references) {
         if (ref.isCorrelated() && ref.getExpression().getGroupSymbol() != null) {
           correleatedGroups.add(ref.getExpression().getGroupSymbol().getName());
         }
       }
       visitor.setCorrelationGroups(correleatedGroups);
     }
     command.acceptVisitor(visitor);
   } catch (QueryMetadataException err) {
     throw new TeiidComponentException(QueryPlugin.Event.TEIID30249, err);
   } catch (TeiidRuntimeException e) {
     if (e.getCause() instanceof QueryPlannerException) {
       throw (QueryPlannerException) e.getCause();
     }
     throw e;
   }
   return command;
 }
示例#4
0
  public void metadataLoadFinished() {
    if (this.metadataloadFinished) {
      return;
    }
    this.metadataloadFinished = true;

    MetadataStore mergedStore = getMetadataStore();
    // the order of the models is important for resolving ddl
    // TODO we might consider not using the intermediate MetadataStore
    List<Schema> schemas = mergedStore.getSchemaList();
    schemas.clear();
    for (ModelMetaData model : this.vdb.getModelMetaDatas().values()) {
      Schema s = mergedStore.getSchema(model.getName());
      if (s != null) {
        schemas.add(s);
      } else {
        mergedStore.getSchemas().remove(model.getName());
      }
    }
    if (this.children != null && !this.children.isEmpty()) {
      for (CompositeVDB child : this.children.values()) {
        MetadataStore childStore = child.getMetadataStore();
        if (childStore != null) {
          mergedStore.merge(childStore);
        }
      }
    }

    TransformationMetadata metadata =
        buildTransformationMetaData(
            mergedVDB,
            getVisibilityMap(),
            mergedStore,
            getUDF(),
            systemFunctions,
            this.additionalStores);
    QueryMetadataInterface qmi = metadata;
    Map<String, String> multiSourceModels =
        MultiSourceMetadataWrapper.getMultiSourceModels(mergedVDB);
    if (multiSourceModels != null && !multiSourceModels.isEmpty()) {
      qmi = new MultiSourceMetadataWrapper(metadata, multiSourceModels);
    }
    mergedVDB.addAttchment(QueryMetadataInterface.class, qmi);
    mergedVDB.addAttchment(TransformationMetadata.class, metadata);
    mergedVDB.addAttchment(MetadataStore.class, mergedStore);
  }
 public void log(ValidatorReport report, ModelMetaData model, Severity severity, String msg) {
   model.addRuntimeMessage(severity, msg);
   if (severity == Severity.ERROR) {
     report.handleValidationError(msg);
   } else {
     report.handleValidationWarning(msg);
   }
 }
    @Override
    public void execute(
        VDBMetaData vdb,
        MetadataStore store,
        ValidatorReport report,
        MetadataValidator metadataValidator) {
      for (Schema schema : store.getSchemaList()) {
        if (vdb.getImportedModels().contains(schema.getName())) {
          continue;
        }
        ModelMetaData model = vdb.getModel(schema.getName());

        if (schema.getTables().isEmpty()
            && schema.getProcedures().isEmpty()
            && schema.getFunctions().isEmpty()) {
          metadataValidator.log(
              report, model, Messages.gs(Messages.TEIID.TEIID31070, model.getName()));
        }

        for (Table t : schema.getTables().values()) {
          if (t.getColumns() == null || t.getColumns().size() == 0) {
            metadataValidator.log(
                report, model, Messages.gs(Messages.TEIID.TEIID31071, t.getFullName()));
          }
          Set<String> names = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
          validateConstraintNames(metadataValidator, report, model, t.getAllKeys(), names);
          validateConstraintNames(
              metadataValidator, report, model, t.getFunctionBasedIndexes(), names);
        }

        // procedure validation is handled in parsing routines.

        if (!schema.getFunctions().isEmpty()) {
          ActivityReport<ReportItem> funcReport =
              new ActivityReport<ReportItem>(
                  "Translator metadata load " + model.getName()); // $NON-NLS-1$
          FunctionMetadataValidator.validateFunctionMethods(
              teiidVersion, schema.getFunctions().values(), report);
          if (report.hasItems()) {
            metadataValidator.log(
                report, model, Messages.gs(Messages.TEIID.TEIID31073, funcReport));
          }
        }
      }
    }
  @BeforeClass
  public static void setUp() throws Exception {
    server = new FakeServer(true);

    LoopbackExecutionFactory loopy = new LoopbackExecutionFactory();
    loopy.setRowCount(10);
    loopy.start();
    server.addTranslator("l", loopy);

    String DDL = "CREATE FOREIGN TABLE G1 (e1 string, e2 integer);";
    ModelMetaData model = new ModelMetaData();
    model.setName("TEMP");
    model.setModelType(Model.Type.PHYSICAL);
    model.setSchemaSourceType("DDL");
    model.setSchemaText(DDL);
    SourceMappingMetadata sm = new SourceMappingMetadata();
    sm.setName("loopy");
    sm.setTranslatorName("l");
    model.addSourceMapping(sm);

    server.deployVDB("test", model);
    conn = server.createConnection("jdbc:teiid:test");
  }
示例#8
0
  private void buildCompositeState(VDBRepository vdbRepository) throws VirtualDatabaseException {
    if (vdb.getVDBImports().isEmpty()) {
      this.vdb.addAttchment(ConnectorManagerRepository.class, this.cmr);
      return;
    }

    VDBMetaData newMergedVDB = this.vdb.clone();
    ConnectorManagerRepository mergedRepo = this.cmr;
    if (!this.cmr.isShared()) {
      mergedRepo = new ConnectorManagerRepository();
      mergedRepo.getConnectorManagers().putAll(this.cmr.getConnectorManagers());
    }
    newMergedVDB.addAttchment(ConnectorManagerRepository.class, mergedRepo);
    ClassLoader[] toSearch = new ClassLoader[vdb.getVDBImports().size() + 1];
    toSearch[0] = this.vdb.getAttachment(ClassLoader.class);
    this.children = new LinkedHashMap<VDBKey, CompositeVDB>();
    newMergedVDB.setImportedModels(new TreeSet<String>(String.CASE_INSENSITIVE_ORDER));
    int i = 1;
    for (VDBImport vdbImport : vdb.getVDBImports()) {
      CompositeVDB importedVDB =
          vdbRepository.getCompositeVDB(new VDBKey(vdbImport.getName(), vdbImport.getVersion()));
      if (importedVDB == null) {
        throw new VirtualDatabaseException(
            RuntimePlugin.Event.TEIID40083,
            RuntimePlugin.Util.gs(
                RuntimePlugin.Event.TEIID40083,
                vdb.getName(),
                vdb.getVersion(),
                vdbImport.getName(),
                vdbImport.getVersion()));
      }
      VDBMetaData childVDB = importedVDB.getVDB();
      newMergedVDB.getVisibilityOverrides().putAll(childVDB.getVisibilityOverrides());
      toSearch[i++] = childVDB.getAttachment(ClassLoader.class);
      this.children.put(new VDBKey(childVDB.getName(), childVDB.getVersion()), importedVDB);

      if (vdbImport.isImportDataPolicies()) {
        for (DataPolicy dp : importedVDB.getVDB().getDataPolicies()) {
          DataPolicyMetadata role = (DataPolicyMetadata) dp;
          if (newMergedVDB.addDataPolicy(role) != null) {
            throw new VirtualDatabaseException(
                RuntimePlugin.Event.TEIID40084,
                RuntimePlugin.Util.gs(
                    RuntimePlugin.Event.TEIID40084,
                    vdb.getName(),
                    vdb.getVersion(),
                    vdbImport.getName(),
                    vdbImport.getVersion(),
                    role.getName()));
          }
          if (role.isGrantAll()) {
            role.setSchemas(childVDB.getModelMetaDatas().keySet());
          }
        }
      }

      // add models
      for (ModelMetaData m : childVDB.getModelMetaDatas().values()) {
        if (newMergedVDB.addModel(m) != null) {
          throw new VirtualDatabaseException(
              RuntimePlugin.Event.TEIID40085,
              RuntimePlugin.Util.gs(
                  RuntimePlugin.Event.TEIID40085,
                  vdb.getName(),
                  vdb.getVersion(),
                  vdbImport.getName(),
                  vdbImport.getVersion(),
                  m.getName()));
        }
        newMergedVDB.getImportedModels().add(m.getName());
        String visibilityOverride =
            newMergedVDB.getPropertyValue(m.getName() + ".visible"); // $NON-NLS-1$
        if (visibilityOverride != null) {
          boolean visible = Boolean.valueOf(visibilityOverride);
          newMergedVDB.setVisibilityOverride(m.getName(), visible);
        }
      }
      ConnectorManagerRepository childCmr =
          childVDB.getAttachment(ConnectorManagerRepository.class);
      if (childCmr == null) {
        throw new AssertionError("childVdb had not connector manager repository"); // $NON-NLS-1$
      }
      if (!this.cmr.isShared()) {
        for (Map.Entry<String, ConnectorManager> entry :
            childCmr.getConnectorManagers().entrySet()) {
          if (mergedRepo.getConnectorManagers().put(entry.getKey(), entry.getValue()) != null) {
            throw new VirtualDatabaseException(
                RuntimePlugin.Event.TEIID40086,
                RuntimePlugin.Util.gs(
                    RuntimePlugin.Event.TEIID40086,
                    vdb.getName(),
                    vdb.getVersion(),
                    vdbImport.getName(),
                    vdbImport.getVersion(),
                    entry.getKey()));
          }
        }
      }
    }
    if (toSearch[0] != null) {
      CombinedClassLoader ccl = new CombinedClassLoader(toSearch[0].getParent(), toSearch);
      this.mergedVDB.addAttchment(ClassLoader.class, ccl);
    }
    this.mergedVDB = newMergedVDB;
  }
    @Override
    public void execute(
        VDBMetaData vdb,
        MetadataStore store,
        ValidatorReport report,
        MetadataValidator metadataValidator) {
      IQueryMetadataInterface metadata = vdb.getAttachment(IQueryMetadataInterface.class);
      metadata = new TempMetadataAdapter(metadata, new TempMetadataStore());
      for (Schema schema : store.getSchemaList()) {
        if (vdb.getImportedModels().contains(schema.getName())) {
          continue;
        }
        ModelMetaData model = vdb.getModel(schema.getName());
        MetadataFactory mf =
            new MetadataFactory(
                teiidVersion, vdb.getName(), vdb.getVersion(), metadataValidator.typeMap, model) {
              @Override
              protected void setUUID(AbstractMetadataRecord record) {
                if (count >= 0) {
                  count = Integer.MIN_VALUE;
                }
                super.setUUID(record);
              }
            };
        mf.setBuiltinDataTypes(store.getDatatypes());
        for (AbstractMetadataRecord record : schema.getResolvingOrder()) {
          if (record instanceof Table) {
            Table t = (Table) record;
            // no need to verify the transformation of the xml mapping document,
            // as this is very specific and designer already validates it.
            if (t.getTableType() == Table.Type.Document
                || t.getTableType() == Table.Type.XmlMappingClass
                || t.getTableType() == Table.Type.XmlStagingTable) {
              continue;
            }
            if (t.isVirtual() && t.getTableType() != Table.Type.TemporaryTable) {
              if (t.getSelectTransformation() == null) {
                metadataValidator.log(
                    report,
                    model,
                    Messages.gs(Messages.TEIID.TEIID31079, t.getFullName(), model.getName()));
              } else {
                metadataValidator.validate(vdb, model, t, report, metadata, mf);
              }
            }
          } else if (record instanceof Procedure) {
            Procedure p = (Procedure) record;

            boolean test = p.isVirtual();
            if (teiidVersion.isLessThan(Version.TEIID_8_11)) test = test && !p.isFunction();

            if (test) {
              if (p.getQueryPlan() == null) {
                metadataValidator.log(
                    report,
                    model,
                    Messages.gs(Messages.TEIID.TEIID31081, p.getFullName(), model.getName()));
              } else {
                metadataValidator.validate(vdb, model, p, report, metadata, mf);
              }
            }
          }
        }
      }
    }
    @Override
    public void execute(
        VDBMetaData vdb,
        MetadataStore store,
        ValidatorReport report,
        MetadataValidator metadataValidator) {
      for (Schema schema : store.getSchemaList()) {
        if (vdb.getImportedModels().contains(schema.getName())) {
          continue;
        }
        ModelMetaData model = vdb.getModel(schema.getName());
        for (Table t : schema.getTables().values()) {
          if (t.isPhysical() && !model.isSource()) {
            metadataValidator.log(
                report,
                model,
                Messages.gs(Messages.TEIID.TEIID31075, t.getFullName(), model.getName()));
          }
        }

        Set<String> names = new HashSet<String>();
        for (Procedure p : schema.getProcedures().values()) {
          boolean hasReturn = false;
          names.clear();
          for (int i = 0; i < p.getParameters().size(); i++) {
            ProcedureParameter param = p.getParameters().get(i);
            if (param.isVarArg() && param != p.getParameters().get(p.getParameters().size() - 1)) {
              // check that the rest of the parameters are optional
              // this accommodates variadic multi-source procedures
              // effective this and the resolving logic ensure that you can used named parameters
              // for everything,
              // or call the vararg procedure as normal
              if (isTeiidOrGreater(Version.TEIID_8_10)) {
                for (int j = i + 1; j < p.getParameters().size(); j++) {
                  ProcedureParameter param1 = p.getParameters().get(j);
                  if ((param1.getType() == Type.In || param1.getType() == Type.InOut)
                      && (param1.isVarArg()
                          || (param1.getNullType() != NullType.Nullable
                              && param1.getDefaultValue() == null))) {
                    metadataValidator.log(
                        report, model, Messages.gs(Messages.TEIID.TEIID31112, p.getFullName()));
                  }
                }
              } else {
                metadataValidator.log(
                    report, model, Messages.gs(Messages.TEIID.TEIID31112, p.getFullName()));
              }
            }
            if (param.getType() == ProcedureParameter.Type.ReturnValue) {
              if (hasReturn) {
                metadataValidator.log(
                    report, model, Messages.gs(Messages.TEIID.TEIID31107, p.getFullName()));
              }
              hasReturn = true;
            } else if (p.isFunction()
                && param.getType() != ProcedureParameter.Type.In
                && teiidVersion.isGreaterThanOrEqualTo(Version.TEIID_8_11)) {
              metadataValidator.log(
                  report,
                  model,
                  Messages.gs(Messages.TEIID.TEIID31165, p.getFullName(), param.getFullName()));
            }
            if (!names.add(param.getName())) {
              metadataValidator.log(
                  report,
                  model,
                  Messages.gs(Messages.TEIID.TEIID31106, p.getFullName(), param.getFullName()));
            }
          }
          if (!p.isVirtual() && !model.isSource()) {
            metadataValidator.log(
                report,
                model,
                Messages.gs(Messages.TEIID.TEIID31077, p.getFullName(), model.getName()));
          }

          if (p.isFunction() && teiidVersion.isGreaterThanOrEqualTo(Version.TEIID_8_11)) {
            if (!hasReturn) {
              metadataValidator.log(
                  report, model, Messages.gs(Messages.TEIID.TEIID31166, p.getFullName()));
            }
            if (p.isVirtual() && p.getQueryPlan() == null) {
              metadataValidator.log(
                  report, model, Messages.gs(Messages.TEIID.TEIID31167, p.getFullName()));
            }
          }
        }

        for (FunctionMethod func : schema.getFunctions().values()) {
          for (FunctionParameter param : func.getInputParameters()) {
            if (param.isVarArg()
                && param != func.getInputParameters().get(func.getInputParameterCount() - 1)) {
              metadataValidator.log(
                  report, model, Messages.gs(Messages.TEIID.TEIID31112, func.getFullName()));
            }
          }
          if (func.getPushdown().equals(FunctionMethod.PushDown.MUST_PUSHDOWN)
              && !model.isSource()) {
            metadataValidator.log(
                report,
                model,
                Messages.gs(Messages.TEIID.TEIID31078, func.getFullName(), model.getName()));
          }
        }
      }
    }