Returns true if this there is no existing one or the same schema has already been registered (this must be done
on application startup).
<p>
NOTE: This is only supported when {@link RuntimeEnv#ID_STRATEGY} is {@link DefaultIdStrategy}.
3808
public static <T> boolean register(Class<T> typeClass, Schema<T> schema)
    {
        if (ID_STRATEGY instanceof DefaultIdStrategy)
            return ((DefaultIdStrategy) ID_STRATEGY).registerPojo(typeClass,
                    schema);

        throw new RuntimeException(
                "RuntimeSchema.register is only supported on DefaultIdStrategy");
    }
1136356
public boolean hasDataSourceConfiguration(final String shardingSchemaName) {
        return !Strings.isNullOrEmpty(regCenter.get(configNode.getDataSourcePath(shardingSchemaName)));
    }
1142443
private boolean isSchemaValid() throws SQLException {
		logger.entering(CLASSNAME, "isSchemaValid");
		Connection conn = getConnectionToDefaultSchema();
		DatabaseMetaData dbmd = conn.getMetaData();
		ResultSet rs = dbmd.getSchemas();
		while(rs.next()) {
			if (schema.equalsIgnoreCase(rs.getString("TABLE_SCHEM")) ) {
				cleanupConnection(conn, rs, null);
				logger.exiting(CLASSNAME, "isSchemaValid", true);
				return true;
			}
		}
		cleanupConnection(conn, rs, null);
		logger.exiting(CLASSNAME, "isSchemaValid", false);
		return false;
	}
478747
@Nonnull
    public static IdStrategy idStrategy() {
        Jenkins j = Jenkins.get();
        SecurityRealm realm = j.getSecurityRealm();
        if (realm == null) {
            return IdStrategy.CASE_INSENSITIVE;
        }
        return realm.getUserIdStrategy();
    }
1049786
public static boolean isField(Schema schema, PartitionStrategy strategy,
                                String name) {
    Schema.Field field = schema.getField(name);
    return ((field != null) ||
        (strategy != null && Accessor.getDefault().hasPartitioner(strategy, name)));
  }
587720
public boolean hasNextQuery() {
		for (int i=0; i<innerLearners.length; i++) {
			if (innerLearners[i].hasNextQuery()) return true;
		}
		return comboHasNextQuery();
	}
1370020
private function determineIdStrategy()
    {
        if ($this->parentMapping && $this->nodename) {
            $this->setIdGenerator(self::GENERATOR_TYPE_PARENT);

            return;
        }
        if ($this->parentMapping) {
            $this->setIdGenerator(self::GENERATOR_TYPE_AUTO);

            return;
        }
        if ($this->getIdentifier()) {
            $this->setIdGenerator(self::GENERATOR_TYPE_ASSIGNED);

            return;
        }

        throw new MappingException(sprintf(
            'No id generator could be determined in "%s". Either map a parent and a nodename field and add values to them, or map the id field and configure a mapping strategy',
            $this->name
        ));
    }
3289
public Where<T, ID> exists(QueryBuilder<?, ?> subQueryBuilder) {
		// we do this to turn off the automatic addition of the ID column in the select column list
		subQueryBuilder.enableInnerQuery();
		addClause(new Exists(new InternalQueryBuilderWrapper(subQueryBuilder)));
		return this;
	}
1173401
private boolean isUniqueImplied(StorableIndex<S> candidate) {
        if (candidate.isUnique()) {
            return true;
        }
        if (this.size() <= 1) {
            return false;
        }

        Set<StorableProperty<S>> candidateProps = new HashSet<StorableProperty<S>>();
        for (int i=candidate.getPropertyCount(); --i>=0; ) {
            candidateProps.add(candidate.getProperty(i));
        }

        search: for (StorableIndex<S> index : this) {
            if (!index.isUnique()) {
                continue search;
            }
            for (int i=index.getPropertyCount(); --i>=0; ) {
                if (!candidateProps.contains(index.getProperty(i))) {
                    continue search;
                }
            }
            return true;
        }

        return false;
    }
893857
@SuppressWarnings("unchecked")
    static JDBCSupportStrategy createStrategy(JDBCRepository repo) {
        String databaseProductName = repo.getDatabaseProductName().trim();
        if (databaseProductName != null && databaseProductName.length() > 0) {
            String strategyName = Character.toUpperCase(databaseProductName.charAt(0))
                + databaseProductName.substring(1).toLowerCase();
            if (strategyName.indexOf(' ') > 0) {
                strategyName = strategyName.substring(0, strategyName.indexOf(' '));
            }
            strategyName = strategyName.replaceAll("[^A-Za-z0-9]", "");
            String className =
                "com.amazon.carbonado.repo.jdbc." + strategyName + "SupportStrategy";
            try {
                Class<JDBCSupportStrategy> clazz =
                    (Class<JDBCSupportStrategy>) Class.forName(className);
                return clazz.getDeclaredConstructor(JDBCRepository.class).newInstance(repo);
            } catch (ClassNotFoundException e) {
                // just use default strategy
            } catch (Exception e) {
                ThrowUnchecked.fireFirstDeclaredCause(e);
            }
        }

        return new JDBCSupportStrategy(repo);
    }
805329
private boolean isPresent(JMFSchema schema) throws JMFSchemaIdException {
    long id = schema.getID();
    JMFSchema reg = (JMFSchema)schemaTable.get(id);
    if (reg != null) {
      // We are assuming that collisions on key don't happen
      if (!schema.equals(reg)) {
        // The schema id is a 64bit SHA-1 derived hashcode, so we really don't expect
        // to get random collisions.
        throw new JMFSchemaIdException("Schema id clash: id=" + id);
      }
      Object newAssoc = schema.getJMFType().getAssociation();
      Object oldAssoc = reg.getJMFType().getAssociation();
      if (newAssoc != oldAssoc && newAssoc != null) {
        if (oldAssoc != null)
          associations.remove(oldAssoc);
        reg.getJMFType().updateAssociations(schema.getJMFType());
        associations.put(newAssoc, reg);
      }
      return true;
    }
    else
      return false;
  }
380357
public function isDefault()
    {
        if ($this->getAttribute()->hasOption(UuidAttribute::OPTION_DEFAULT_VALUE)
            && $this->getAttribute()->getOption(UuidAttribute::OPTION_DEFAULT_VALUE) !== 'auto_gen'
        ) {
            return $this->sameValueAs($this->getAttribute()->getDefaultValue());
        }

        throw new RuntimeException(
            'Operation not supported. A new UUIDv4 is generated for every getNullValue call. No default value set.'
        );
    }
1205392
public RedGBuilder<T> withDefaultValueStrategy(final DefaultValueStrategy strategy) {
        if (instance == null) {
            throw new IllegalStateException("Using the builder after build() was called is not allowed!");
        }
        instance.setDefaultValueStrategy(strategy);
        return this;
    }
351941
public boolean hasBeanAsParameter() {
		TypeName entityTypeName = TypeUtility.typeName(this.getEntity().getElement());

		for (Pair<String, TypeName> item : this.parameters) {
			if (item.value1.equals(entityTypeName)) {
				return true;
			}
		}

		return false;
	}
959960
public boolean sameUniqueID(String uniqueID)
    {
        boolean equals = false;
        if ((this._uniqueID.compareTo(ChannelImpl.UNKNOWN_UNIQUE_ID) != 0)
                && (uniqueID.compareTo(ChannelImpl.UNKNOWN_UNIQUE_ID) != 0))
        {
            if (this._uniqueID.compareTo(uniqueID) == 0)
            {
                equals = true;
            }
        }

        return equals;
    }
395417
public boolean isFilled() {
        boolean isFilled = false;

        if (this.originalSql != null && this.originalSql.length() > 0) {
            if (this.parsedSql != null && this.parsedSql.length() > 0) {
                if (this.sqlParameterNames != null) {
                    if (this.sqlParameterValues != null) {
                        isFilled = true;
                    }
                }
            }
        }

        return isFilled;
    }
737987
public boolean hasPrevious() throws DBException
    {
        if (m_iCurrentRecord >= m_iRecordsAccessed)
            return true;
        Object record = this.previous();
        if (record == null)
            return false;
        else
        {
            m_iRecordsAccessed--;   // Offically this record has not been accessed
            return true;
        }
    }