コード例 #1
0
  @Test
  public void run() throws SQLException {
    Connection connection = connection();

    Tools.title("Distinguishing between static and prepared statements with JDBC");

    // 1% of the time
    try (Statement stmt = connection.createStatement()) {
      stmt.execute("SELECT * FROM AUTHOR");
    }

    // 99% of the time
    try (PreparedStatement stmt = connection.prepareStatement("SELECT * FROM AUTHOR")) {
      stmt.execute();
    }

    Tools.title("Distinguishing between static and prepared statements with jOOQ");
    // 1% of the time
    System.out.println(
        DSL.using(connection, new Settings().withStatementType(StatementType.STATIC_STATEMENT))
            .fetch("SELECT * FROM AUTHOR"));

    // 99% of the time
    System.out.println(DSL.using(connection).fetch("SELECT * FROM AUTHOR"));
  }
コード例 #2
0
 @Override
 public boolean isProjectOwner(
     long projectId, Long usingAccount, boolean isAdmin, Set<Identity> identities) {
   if (identities == null) {
     return false;
   }
   if (isAdmin) {
     return true;
   }
   if (usingAccount != null && usingAccount.equals(projectId)) {
     return false;
   }
   Set<ProjectMemberRecord> projectMembers = new HashSet<>();
   Condition allMembers = DSL.falseCondition();
   for (Identity id : identities) {
     allMembers =
         allMembers.or(
             PROJECT_MEMBER
                 .EXTERNAL_ID
                 .eq(id.getExternalId())
                 .and(PROJECT_MEMBER.EXTERNAL_ID_TYPE.eq(id.getExternalIdType()))
                 .and(PROJECT_MEMBER.ROLE.eq(ProjectConstants.OWNER))
                 .and(PROJECT_MEMBER.PROJECT_ID.eq(projectId))
                 .and(PROJECT_MEMBER.STATE.eq(CommonStatesConstants.ACTIVE))
                 .and(PROJECT_MEMBER.REMOVED.isNull()));
   }
   projectMembers.addAll(create().selectFrom(PROJECT_MEMBER).where(allMembers).fetch());
   return !projectMembers.isEmpty();
 }
コード例 #3
0
  @SuppressFBWarnings("SQL_NONCONSTANT_STRING_PASSED_TO_EXECUTE")
  public static void execute(
      Configuration jooqConf,
      IndexStorage.CollectionSchema colSchema,
      @Nonnull DatabaseInterface databaseInterface) {

    ConnectionProvider provider = jooqConf.connectionProvider();
    Connection connection = provider.acquire();
    Statement st = null;
    try {
      st = connection.createStatement();
      st.executeUpdate(databaseInterface.dropSchemaStatement(colSchema.getName()));

      DSLContext dsl = DSL.using(jooqConf);
      int deleted =
          dsl.deleteFrom(CollectionsTable.COLLECTIONS)
              .where(CollectionsTable.COLLECTIONS.NAME.eq(colSchema.getCollection()))
              .execute();
      assert deleted == 1;
    } catch (SQLException ex) {
      throw new ToroImplementationException(ex);
    } finally {
      AutoCloser.close(st);
    }
  }
コード例 #4
0
ファイル: AllocatorDaoImpl.java プロジェクト: kalw/cattle
  protected Condition vnetCondition(Long vnetId) {
    if (vnetId == null) {
      return DSL.trueCondition();
    }

    return VNET.ID.eq(vnetId);
  }
コード例 #5
0
    @Override
    public Object map(R record) {
      AbstractRecord copy = (AbstractRecord) DSL.using(configuration).newRecord(f);

      for (int i = 0; i < f.length; i++) if (f[i] != null) copy.setValue(i, record.getValue(i));

      return d.map(record);
    }
コード例 #6
0
 private static SelectConditionStep<Record1<Integer>> countSensorData(Field<Integer> datasetId) {
   return DSL.selectCount()
       .from(SENSORED_DATA)
       .join(DATA)
       .on(SENSORED_DATA.DATA.eq(DATA.ID)) // sensored_data -> data
       .where(DATA.DATASET_ID.eq(datasetId))
       .and(isIncludedAndNotHidden(DATA));
 }
コード例 #7
0
 private static SelectConditionStep<Record1<Integer>> countLayerData(Field<Integer> datasetId) {
   return DSL.selectCount()
       .from(LAYER)
       .join(DATA)
       .on(LAYER.DATA.eq(DATA.ID)) // layer -> data
       .where(DATA.DATASET_ID.eq(datasetId))
       .and(isIncludedAndNotHidden(DATA));
 }
コード例 #8
0
 private static SelectConditionStep<Record1<Integer>> countDataOfType(
     Field<Integer> datasetId, String type) {
   return DSL.selectCount()
       .from(DATA)
       .where(DATA.DATASET_ID.eq(datasetId))
       .and(isIncludedAndNotHidden(DATA))
       .and(DATA.TYPE.eq(type));
 }
コード例 #9
0
ファイル: Tanh.java プロジェクト: hnlaomie/jooq-3.1
  @Override
  final Field<BigDecimal> getFunction0(Configuration configuration) {
    switch (configuration.dialect().family()) {
      case ASE:
      case CUBRID:
      case HSQLDB:
      case INGRES:
      case MARIADB:
      case MYSQL:
      case POSTGRES:
      case SQLSERVER:
      case SYBASE:
        return DSL.exp(argument.mul(two())).sub(one()).div(DSL.exp(argument.mul(two())).add(one()));

      default:
        return function("tanh", SQLDataType.NUMERIC, argument);
    }
  }
コード例 #10
0
  /**
   * returns all the open Calibrations needed from the worker
   *
   * @param experimentID the experiment
   * @param platformID the id of the platform
   * @param worker the worker
   * @return a map where the keys are the detailed population the worker may belong to and the
   *     values are the answerOptions
   */
  public Map<CalibrationRecord, Result<CalibrationAnswerOptionRecord>> getCalibrations(
      int experimentID, String platformID, int worker) {
    SelectConditionStep<Record1<Integer>> alreadyAnsweredCalibrations =
        DSL.select(CALIBRATION_ANSWER_OPTION.CALIBRATION)
            .from(Tables.CALIBRATION_ANSWER_OPTION)
            .join(Tables.CALIBRATION_RESULT)
            .onKey()
            .where(Tables.CALIBRATION_RESULT.WORKER.eq(worker));

    Map<CalibrationRecord, Result<Record>> calibrationAndAnswers =
        create
            .select(CALIBRATION.fields())
            .select(CALIBRATION_ANSWER_OPTION.fields())
            .from(Tables.CALIBRATION_ANSWER_OPTION)
            .join(Tables.CALIBRATION)
            .onKey()
            // we want all the calibrations
            .where(
                CALIBRATION.ID_CALIBRATION.in(
                    // which belong to the chosen answer-option
                    DSL.select(CALIBRATION_ANSWER_OPTION.CALIBRATION)
                        .from(CALIBRATION_ANSWER_OPTION)
                        .where(
                            CALIBRATION_ANSWER_OPTION.ID_CALIBRATION_ANSWER_OPTION.in(
                                // from the experiment
                                DSL.select(EXPERIMENTS_CALIBRATION.ANSWER)
                                    .from(EXPERIMENTS_CALIBRATION)
                                    .where(
                                        EXPERIMENTS_CALIBRATION.EXPERIMENTS_PLATFORM.eq(
                                            // from the platform
                                            DSL.select(EXPERIMENTS_PLATFORM.IDEXPERIMENTS_PLATFORMS)
                                                .from(EXPERIMENTS_PLATFORM)
                                                .where(
                                                    EXPERIMENTS_PLATFORM.EXPERIMENT.eq(
                                                        experimentID))
                                                .and(
                                                    EXPERIMENTS_PLATFORM.PLATFORM.eq(
                                                        platformID))))))))
            .and(Tables.CALIBRATION.ID_CALIBRATION.notIn(alreadyAnsweredCalibrations))
            .fetchGroups(Tables.CALIBRATION);

    return mapMap(
        calibrationAndAnswers, result -> result.into(Tables.CALIBRATION_ANSWER_OPTION.asTable()));
  }
コード例 #11
0
ファイル: Greatest.java プロジェクト: binque/jOOQ
  @SuppressWarnings("unchecked")
  @Override
  final Field<T> getFunction0(Configuration configuration) {

    // In any dialect, a single argument is always the greatest
    if (getArguments().length == 1) {
      return (Field<T>) getArguments()[0];
    }

    switch (configuration.dialect()) {
        // This implementation has O(2^n) complexity. Better implementations
        // are very welcome
        // [#1049] TODO Fix this!

      case ASE:
      case DERBY:
      case SQLSERVER:
      case SYBASE:
        {
          Field<T> first = (Field<T>) getArguments()[0];
          Field<T> other = (Field<T>) getArguments()[1];

          if (getArguments().length > 2) {
            Field<?>[] remaining = new Field[getArguments().length - 2];
            System.arraycopy(getArguments(), 2, remaining, 0, remaining.length);

            return DSL.decode()
                .when(first.greaterThan(other), DSL.greatest(first, remaining))
                .otherwise(DSL.greatest(other, remaining));
          } else {
            return DSL.decode().when(first.greaterThan(other), first).otherwise(other);
          }
        }

      case FIREBIRD:
        return function("maxvalue", getDataType(), getArguments());

      case SQLITE:
        return function("max", getDataType(), getArguments());

      default:
        return function("greatest", getDataType(), getArguments());
    }
  }
コード例 #12
0
  /**
   * returns whether the worker already has submitted the wrong calibrations
   *
   * @param experimentID the current experiment
   * @param platformID the platform the worker is working on
   * @param worker the worker to check for
   * @return true if the worker is already belonging to the wrong population, false if not
   */
  public boolean hasSubmittedWrongCalibrations(int experimentID, String platformID, int worker) {
    SelectConditionStep<Record1<Integer>> getCalibrationForExperiment =
        DSL.select(CALIBRATION_ANSWER_OPTION.CALIBRATION)
            .from(CALIBRATION_ANSWER_OPTION)
            .where(
                CALIBRATION_ANSWER_OPTION.ID_CALIBRATION_ANSWER_OPTION.eq(
                    EXPERIMENTS_CALIBRATION.ANSWER));

    SelectConditionStep<Record1<Integer>> getExperimentPlatformIds =
        DSL.select(EXPERIMENTS_PLATFORM.IDEXPERIMENTS_PLATFORMS)
            .from(EXPERIMENTS_PLATFORM)
            .where(EXPERIMENTS_PLATFORM.EXPERIMENT.eq(experimentID))
            .and(EXPERIMENTS_PLATFORM.PLATFORM.eq(platformID));

    return create.fetchExists(
        DSL.select()
            .from(CALIBRATION_ANSWER_OPTION)
            .innerJoin(CALIBRATION_RESULT)
            .onKey()
            .innerJoin(EXPERIMENTS_CALIBRATION)
            .on(
                EXPERIMENTS_CALIBRATION
                    .EXPERIMENTS_PLATFORM
                    .in(getExperimentPlatformIds)
                    .and(CALIBRATION_ANSWER_OPTION.CALIBRATION.eq(getCalibrationForExperiment))
                    .and(
                        EXPERIMENTS_CALIBRATION
                            .NOT
                            .eq(true)
                            .and(
                                EXPERIMENTS_CALIBRATION.ANSWER.eq(
                                    CALIBRATION_ANSWER_OPTION.ID_CALIBRATION_ANSWER_OPTION))
                            .or(
                                EXPERIMENTS_CALIBRATION
                                    .NOT
                                    .eq(false)
                                    .and(
                                        EXPERIMENTS_CALIBRATION.ANSWER.notEqual(
                                            CALIBRATION_ANSWER_OPTION
                                                .ID_CALIBRATION_ANSWER_OPTION)))))
            .where(CALIBRATION_RESULT.WORKER.eq(worker)));
  }
コード例 #13
0
ファイル: CreditCard.java プロジェクト: binque/jOOQ
 /** {@inheritDoc} */
 @Override
 public org.jooq.Row6<
         java.lang.Integer,
         java.lang.String,
         java.lang.String,
         java.lang.Byte,
         java.lang.Short,
         java.sql.Timestamp>
     fieldsRow() {
   return org.jooq.impl.DSL.row(field1(), field2(), field3(), field4(), field5(), field6());
 }
コード例 #14
0
  private void connect() {
    try {
      Class.forName("org.sqlite.JDBC");
      conn = DriverManager.getConnection(url);
      dsl = DSL.using(conn, SQLDialect.SQLITE);
    } catch (ClassNotFoundException ex) {

    } catch (SQLException ex) {

    }
  }
コード例 #15
0
ファイル: CreditCard.java プロジェクト: binque/jOOQ
 /** {@inheritDoc} */
 @Override
 public org.jooq.Row6<
         java.lang.Integer,
         java.lang.String,
         java.lang.String,
         java.lang.Byte,
         java.lang.Short,
         java.sql.Timestamp>
     valuesRow() {
   return org.jooq.impl.DSL.row(value1(), value2(), value3(), value4(), value5(), value6());
 }
コード例 #16
0
  @Override
  public List<Account> getAccessibleProjects(
      Set<Identity> identities, boolean isAdmin, Long usingAccount) {
    List<Account> projects = new ArrayList<>();
    if (identities == null) {
      return projects;
    }
    if (isAdmin) {
      projects.addAll(
          create()
              .selectFrom(ACCOUNT)
              .where(ACCOUNT.KIND.eq(ProjectConstants.TYPE).and(ACCOUNT.REMOVED.isNull()))
              .orderBy(ACCOUNT.ID.asc())
              .fetch());
      return projects;
    }

    if (usingAccount != null) {
      Account project = getAccountById(usingAccount);
      if (project != null && project.getKind().equalsIgnoreCase(ProjectConstants.TYPE)) {
        projects.add(project);
        return projects;
      }
    }
    // DSL.falseCondition is created so that we can dynamically build a or
    // Condition without caring what the external Ids are and still make one
    // Database call.
    Condition allMembers = DSL.falseCondition();
    for (Identity id : identities) {
      allMembers =
          allMembers.or(
              PROJECT_MEMBER
                  .EXTERNAL_ID
                  .eq(id.getExternalId())
                  .and(PROJECT_MEMBER.EXTERNAL_ID_TYPE.eq(id.getExternalIdType()))
                  .and(PROJECT_MEMBER.REMOVED.isNull())
                  .and(PROJECT_MEMBER.STATE.eq(CommonStatesConstants.ACTIVE)));
    }
    SelectQuery<Record> query = create().selectQuery();
    query.addFrom(ACCOUNT);
    query.addJoin(PROJECT_MEMBER, PROJECT_MEMBER.PROJECT_ID.equal(ACCOUNT.ID));
    query.addConditions(allMembers);
    query.setDistinct(true);
    projects.addAll(query.fetchInto(ACCOUNT));
    Map<Long, Account> returnProjects = new HashMap<>();
    for (Account project : projects) {
      returnProjects.put(project.getId(), project);
    }
    projects = new ArrayList<>();
    projects.addAll(returnProjects.values());
    return projects;
  }
コード例 #17
0
ファイル: Least.java プロジェクト: kevintanhongann/jOOQ
  @SuppressWarnings("unchecked")
  @Override
  final Field<T> getFunction0(Configuration configuration) {

    // In any dialect, a single argument is always the least
    if (getArguments().length == 1) {
      return (Field<T>) getArguments()[0];
    }

    switch (configuration.family()) {
        // This implementation has O(2^n) complexity. Better implementations
        // are very welcome

      case DERBY:
        {
          Field<T> first = (Field<T>) getArguments()[0];
          Field<T> other = (Field<T>) getArguments()[1];

          if (getArguments().length > 2) {
            Field<?>[] remaining = new Field<?>[getArguments().length - 2];
            System.arraycopy(getArguments(), 2, remaining, 0, remaining.length);

            return DSL.when(first.lessThan(other), DSL.least(first, remaining))
                .otherwise(DSL.least(other, remaining));
          } else {
            return DSL.when(first.lessThan(other), first).otherwise(other);
          }
        }

      case FIREBIRD:
        return function("minvalue", getDataType(), getArguments());

      case SQLITE:
        return function("min", getDataType(), getArguments());

      default:
        return function("least", getDataType(), getArguments());
    }
  }
コード例 #18
0
  @Override
  public void deleteChargePoint(int chargeBoxPk) {
    ctx.transaction(
        configuration -> {
          DSLContext ctx = DSL.using(configuration);
          try {
            addressRepository.delete(ctx, selectAddressId(chargeBoxPk));
            deleteChargePointInternal(ctx, chargeBoxPk);

          } catch (DataAccessException e) {
            throw new SteveException("Failed to delete the charge point", e);
          }
        });
  }
コード例 #19
0
  @Override
  public int addChargePoint(ChargePointForm form) {
    return ctx.transactionResult(
        configuration -> {
          DSLContext ctx = DSL.using(configuration);
          try {
            Integer addressId = addressRepository.updateOrInsert(ctx, form.getAddress());
            return addChargePointInternal(ctx, form, addressId);

          } catch (DataAccessException e) {
            throw new SteveException(
                "Failed to add the charge point with chargeBoxId '%s'", form.getChargeBoxId(), e);
          }
        });
  }
コード例 #20
0
  public static void main(String[] args) throws IOException, SQLException {
    ResourceLoader loader = Hsqldb.keggReactionLoader();
    loader.addLocation("kegg.reaction", new SystemLocation("/databases/kegg/ligand/reaction"));
    if (loader.canBackup()) loader.backup();
    long t0 = System.nanoTime();
    loader.update();
    long t1 = System.nanoTime();
    System.out.println(TimeUnit.NANOSECONDS.toMillis(t1 - t0) + " ms");

    Connection connection = Hsqldb.keggReactionConnection().getConnection();
    DSLContext context = DSL.using(connection, HSQLDB);
    System.out.println(context.select().from(REACTION).fetch());
    System.out.println(context.select().from(COMPOUND).fetch());
    System.out.println(context.select().from(REACTANT).fetch());
    System.out.println(context.select().from(PRODUCT).fetch());
    connection.close();
  }
コード例 #21
0
  @Before
  public void setUp() {
    String userName = "******";
    String password = "******";
    String url = "jdbc:mysql://localhost:3306/library";

    // Connection is the only JDBC resource that we need
    // PreparedStatement and ResultSet are handled by jOOQ, internally
    try {
      conn = DriverManager.getConnection(url, userName, password);
      if (create == null) create = DSL.using(conn, SQLDialect.MYSQL);
    }

    // For the sake of this tutorial, let's keep exception handling simple
    catch (Exception e) {
      e.printStackTrace();
    }
  }
コード例 #22
0
 public List<? extends ProjectMember> getProjectMembersByIdentity(
     long projectId, Set<Identity> identities) {
   Condition allMembers = DSL.falseCondition();
   for (Identity identity : identities) {
     allMembers =
         allMembers.or(
             PROJECT_MEMBER
                 .EXTERNAL_ID
                 .eq(identity.getExternalId())
                 .and(PROJECT_MEMBER.EXTERNAL_ID_TYPE.eq(identity.getExternalIdType()))
                 .and(PROJECT_MEMBER.REMOVED.isNull())
                 .and(PROJECT_MEMBER.STATE.eq(CommonStatesConstants.ACTIVE))
                 .and(PROJECT_MEMBER.PROJECT_ID.eq(projectId)));
   }
   SelectQuery<Record> query = create().selectQuery();
   query.addFrom(PROJECT_MEMBER);
   query.addConditions(allMembers);
   query.setDistinct(true);
   return query.fetchInto(PROJECT_MEMBER);
 }
コード例 #23
0
ファイル: Nvl.java プロジェクト: nablaone/jOOQ
  @Override
  final Field<T> getFunction0(Configuration configuration) {
    switch (configuration.family()) {
      case H2:
      case HSQLDB:
        return field("{nvl}({0}, {1})", getDataType(), arg1, arg2);

      case DERBY:
      case POSTGRES:
        return field("{coalesce}({0}, {1})", getDataType(), arg1, arg2);

      case MARIADB:
      case MYSQL:
      case SQLITE:
        return field("{ifnull}({0}, {1})", getDataType(), arg1, arg2);

      default:
        return DSL.when(arg1.isNotNull(), arg1).otherwise(arg2);
    }
  }
コード例 #24
0
  @Override
  public List<ConnectorStatus> getChargePointConnectorStatus() {
    // Prepare for the inner select of the second join
    Field<Integer> t1Pk = CONNECTOR_STATUS.CONNECTOR_PK.as("t1_pk");
    Field<DateTime> t1Max = DSL.max(CONNECTOR_STATUS.STATUS_TIMESTAMP).as("t1_max");
    TableLike<?> t1 =
        ctx.select(t1Pk, t1Max)
            .from(CONNECTOR_STATUS)
            .groupBy(CONNECTOR_STATUS.CONNECTOR_PK)
            .asTable("t1");

    return ctx.select(
            CHARGE_BOX.CHARGE_BOX_PK,
            CONNECTOR.CHARGE_BOX_ID,
            CONNECTOR.CONNECTOR_ID,
            CONNECTOR_STATUS.STATUS_TIMESTAMP,
            CONNECTOR_STATUS.STATUS,
            CONNECTOR_STATUS.ERROR_CODE)
        .from(CONNECTOR_STATUS)
        .join(CONNECTOR)
        .onKey()
        .join(CHARGE_BOX)
        .on(CHARGE_BOX.CHARGE_BOX_ID.eq(CONNECTOR.CHARGE_BOX_ID))
        .join(t1)
        .on(CONNECTOR_STATUS.CONNECTOR_PK.equal(t1.field(t1Pk)))
        .and(CONNECTOR_STATUS.STATUS_TIMESTAMP.equal(t1.field(t1Max)))
        .orderBy(CONNECTOR_STATUS.STATUS_TIMESTAMP.desc())
        .fetch()
        .map(
            r ->
                ConnectorStatus.builder()
                    .chargeBoxPk(r.value1())
                    .chargeBoxId(r.value2())
                    .connectorId(r.value3())
                    .timeStamp(DateTimeUtils.humanize(r.value4()))
                    .status(r.value5())
                    .errorCode(r.value6())
                    .build());
  }
コード例 #25
0
ファイル: Rpad.java プロジェクト: nablaone/jOOQ
  @Override
  final Field<String> getFunction0(Configuration configuration) {
    switch (configuration.family()) {

        // This beautiful expression was contributed by "Ludo", here:
        // http://stackoverflow.com/questions/6576343/how-to-simulate-lpad-rpad-with-sqlite
      case SQLITE:
        {
          return DSL.field(
              "{0} || substr("
                  + "replace("
                  + "replace("
                  + "substr("
                  + "quote("
                  + "zeroblob((({1} - length({0}) - 1 + length({2})) / length({2}) + 1) / 2)"
                  + "), 3"
                  + "), '\''', ''"
                  + "), '0', {2}"
                  + "), 1, ({1} - length({0}))"
                  + ")",
              String.class, field, length, character);
        }

        // According to the Firebird documentation, LPAD outcomes should be
        // cast to truncate large results...
      case FIREBIRD:
        {
          return field(
              "cast(rpad({0}, {1}, {2}) as varchar(4000))",
              SQLDataType.VARCHAR, field, length, character);
        }

      default:
        {
          return function("rpad", SQLDataType.VARCHAR, field, length, character);
        }
    }
  }
コード例 #26
0
ファイル: vJobCandidate.java プロジェクト: binque/jOOQ
 /** {@inheritDoc} */
 @Override
 public org.jooq.Row16<
         java.lang.Integer,
         java.lang.Integer,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.sql.Timestamp>
     valuesRow() {
   return org.jooq.impl.DSL.row(
       value1(), value2(), value3(), value4(), value5(), value6(), value7(), value8(), value9(),
       value10(), value11(), value12(), value13(), value14(), value15(), value16());
 }
コード例 #27
0
ファイル: vJobCandidate.java プロジェクト: binque/jOOQ
 /** {@inheritDoc} */
 @Override
 public org.jooq.Row16<
         java.lang.Integer,
         java.lang.Integer,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.lang.String,
         java.sql.Timestamp>
     fieldsRow() {
   return org.jooq.impl.DSL.row(
       field1(), field2(), field3(), field4(), field5(), field6(), field7(), field8(), field9(),
       field10(), field11(), field12(), field13(), field14(), field15(), field16());
 }
コード例 #28
0
 @Override
 public DSLContext get() {
   Configuration configuration =
       new DefaultConfiguration().set(ultm.getManagedDataSource()).set(SQLDialect.POSTGRES);
   return DSL.using(configuration);
 }
コード例 #29
0
ファイル: MySQLDatabase.java プロジェクト: binque/jOOQ
 @Override
 protected DSLContext create0() {
   return DSL.using(getConnection(), SQLDialect.MYSQL);
 }
コード例 #30
0
ファイル: Supplier.java プロジェクト: snp0k/warehouse
/** This class is generated by jOOQ. */
@Generated(
    value = {"http://www.jooq.org", "jOOQ version:3.8.4"},
    comments = "This class is generated by jOOQ")
@SuppressWarnings({"all", "unchecked", "rawtypes"})
public class Supplier extends TableImpl<SupplierRecord> {

  private static final long serialVersionUID = 145075241;

  /** The reference instance of <code>warehouse.Supplier</code> */
  public static final Supplier SUPPLIER = new Supplier();

  /** The class holding records for this type */
  @Override
  public Class<SupplierRecord> getRecordType() {
    return SupplierRecord.class;
  }

  /** The column <code>warehouse.Supplier.id</code>. */
  public final TableField<SupplierRecord, Long> ID =
      createField("id", org.jooq.impl.SQLDataType.BIGINT.nullable(false), this, "");

  /** The column <code>warehouse.Supplier.code</code>. */
  public final TableField<SupplierRecord, String> CODE =
      createField("code", org.jooq.impl.SQLDataType.VARCHAR.length(255).nullable(false), this, "");

  /** The column <code>warehouse.Supplier.name</code>. */
  public final TableField<SupplierRecord, String> NAME =
      createField("name", org.jooq.impl.SQLDataType.VARCHAR.length(255).nullable(false), this, "");

  /** The column <code>warehouse.Supplier.dateCreated</code>. */
  public final TableField<SupplierRecord, Timestamp> DATECREATED =
      createField(
          "dateCreated",
          org.jooq.impl.SQLDataType.TIMESTAMP
              .nullable(false)
              .defaultValue(
                  org.jooq.impl.DSL.inline(
                      "CURRENT_TIMESTAMP", org.jooq.impl.SQLDataType.TIMESTAMP)),
          this,
          "");

  /** Create a <code>warehouse.Supplier</code> table reference */
  public Supplier() {
    this("Supplier", null);
  }

  /** Create an aliased <code>warehouse.Supplier</code> table reference */
  public Supplier(String alias) {
    this(alias, SUPPLIER);
  }

  private Supplier(String alias, Table<SupplierRecord> aliased) {
    this(alias, aliased, null);
  }

  private Supplier(String alias, Table<SupplierRecord> aliased, Field<?>[] parameters) {
    super(alias, null, aliased, parameters, "");
  }

  /** {@inheritDoc} */
  @Override
  public Schema getSchema() {
    return warehouse.WAREHOUSE;
  }

  /** {@inheritDoc} */
  @Override
  public Identity<SupplierRecord, Long> getIdentity() {
    return Keys.IDENTITY_SUPPLIER;
  }

  /** {@inheritDoc} */
  @Override
  public UniqueKey<SupplierRecord> getPrimaryKey() {
    return Keys.KEY_SUPPLIER_PRIMARY;
  }

  /** {@inheritDoc} */
  @Override
  public List<UniqueKey<SupplierRecord>> getKeys() {
    return Arrays.<UniqueKey<SupplierRecord>>asList(
        Keys.KEY_SUPPLIER_PRIMARY, Keys.KEY_SUPPLIER_CODE);
  }

  /** {@inheritDoc} */
  @Override
  public Supplier as(String alias) {
    return new Supplier(alias, this);
  }

  /** Rename this table */
  public Supplier rename(String name) {
    return new Supplier(name, null);
  }
}