Create the schema if necessary.
@return {@code true} if the schema was created
@see DataSourceProperties#getSchema()
9864
public boolean createSchema() {
		List<Resource> scripts = getScripts("spring.datasource.schema",
				this.properties.getSchema(), "schema");
		if (!scripts.isEmpty()) {
			if (!isEnabled()) {
				logger.debug("Initialization disabled (not running DDL scripts)");
				return false;
			}
			String username = this.properties.getSchemaUsername();
			String password = this.properties.getSchemaPassword();
			runScripts(scripts, username, password);
		}
		return !scripts.isEmpty();
	}
40556
public java.util.List<SchemaExtensionInfo> getSchemaExtensionsInfo() {
        if (schemaExtensionsInfo == null) {
            schemaExtensionsInfo = new com.amazonaws.internal.SdkInternalList<SchemaExtensionInfo>();
        }
        return schemaExtensionsInfo;
    }
1261461
private synchronized Schema getInputPathAvroSchema() throws IOException {
        if (inputPathAvroSchema == null) {
            // No need to query Hadoop more than once as this shouldn't change mid-run,
            // thus, we can lazily initialize and cache the result.
            inputPathAvroSchema = AvroUtils.getAvroSchemaFromPath(getInputPath());
        }
        return inputPathAvroSchema;
    }
90421
@Nonnull
  public final Schema getSchema (@Nonnull final IReadableResource aResource)
  {
    ValueEnforcer.notNull (aResource, "Resource");

    return getFromCache (new CommonsArrayList <> (aResource));
  }
1202436
private String getSchema() {
        if (Utils.isEmpty(m_config.schema)) {
            m_config.schema = m_config.root + m_config.app + ".xml";
        }
        File schemaFile = new File(m_config.schema);
        if (!schemaFile.exists()) {
            logErrorThrow("Schema file not found: {}", m_config.schema);
        }
        StringBuilder schemaBuffer = new StringBuilder();
        char[] charBuffer = new char[65536];
        try (FileReader reader = new FileReader(schemaFile)) {
            for (int bytesRead = reader.read(charBuffer); bytesRead > 0; bytesRead = reader.read(charBuffer)) {
                schemaBuffer.append(charBuffer, 0, bytesRead);
            }
        } catch (Exception e) {
            logErrorThrow("Cannot read schema file '{}': {}", m_config.schema, e);
        }
        return schemaBuffer.toString();
    }
514019
public ArrayList<SchemaField> getSchema()
    {
        final ArrayList<SchemaField> items = new ArrayList<SchemaField>(schemaFields.values());

        Collections.sort(items, new Comparator<SchemaField>()
        {
            @Override
            public int compare(final SchemaField left, final SchemaField right)
            {
                return left.getId() - right.getId();
            }
        });

        return items;
    }
431774
private Path getOrGenerateSchemaFile(Schema schema) throws IOException {

    Preconditions.checkNotNull(schema, "Avro Schema should not be null");

    String hashedSchema = Hashing.sha256().hashString(schema.toString(), StandardCharsets.UTF_8).toString();

    if (!this.schemaPaths.containsKey(hashedSchema)) {

      Path schemaFilePath = new Path(this.schemaDir, String.valueOf(System.currentTimeMillis() + ".avsc"));
      AvroUtils.writeSchemaToFile(schema, schemaFilePath, fs, true);

      this.schemaPaths.put(hashedSchema, schemaFilePath);
    }

    return this.schemaPaths.get(hashedSchema);
  }
1141714
protected function createSchema()
    {
        $schema = new ModelSchema("Job");
        $schema->addColumn(
            new AutoIncrementColumn("JobID"),
            new StringColumn("JobTitle", 100),
            new StringColumn("Status", 100),
            new BooleanColumn("Sent"));

        return $schema;
    }
208455
public function getSchema()
    {
        if ($this->_schema === null) {
            $this->_schema = $this->_initializeSchema(
                $this->getConnection()
                    ->getSchemaCollection()
                    ->describe($this->getTable())
            );
        }

        return $this->_schema;
    }
777987
private boolean getSchemaManagementStatus(DBConnection dbc) {

        boolean createSchemas = false;
        if (dbc.isDerby()) {
            createSchemas = true;
        } else if (dbc.isMysql() || dbc.isPostgresql()) {
            createSchemas = getSystemConfiguration().getSystemManagedSchemas();
        }
        return createSchemas;
    }
966822
public boolean create() {
		if (!exists()) {
			node = mobicentsCache.getJBossCache().getRoot().addChild(nodeFqn);
			if (doTraceLogs) {
				logger.trace("created cache node "+nodeFqn);
			}
			return true;
		}
		else {
			return false;
		}
	}
772591
private void createSchemaOnDb() {
        StringBuilder sql = new StringBuilder();
        sql.append(topology.getSqlgGraph().getSqlDialect().createSchemaStatement(this.name));
        if (this.sqlgGraph.getSqlDialect().needsSemicolon()) {
            sql.append(";");
        }
        if (logger.isDebugEnabled()) {
            logger.debug(sql.toString());
        }
        Connection conn = this.sqlgGraph.tx().getConnection();
        try (Statement stmt = conn.createStatement()) {
            stmt.execute(sql.toString());
        } catch (SQLException e) {
            logger.error("schema creation failed " + this.sqlgGraph.toString(), e);
            throw new RuntimeException(e);
        }
    }
18889
protected static String createUniqueSchema() {
        String uuid = UUID.randomUUID().toString();
        uuid = allowedSchemaChars.retainFrom(uuid);
        String schema = 'u' + uuid;
        return schema;
    }
151120
protected TableSchema getSchema() {
    List<TableFieldSchema> fields = new ArrayList<>();
    for (Map.Entry<String, FieldInfo<InputT>> entry : fieldInfo.entrySet()) {
      String key = entry.getKey();
      FieldInfo<InputT> fcnInfo = entry.getValue();
      String bqType = fcnInfo.getFieldType();
      fields.add(new TableFieldSchema().setName(key).setType(bqType));
    }
    return new TableSchema().setFields(fields);
  }
1276775
public function getSchema()
    {
        if (!isset($this->schema)) {
            $class = '\\Wslim\\Db\\Schema\\' . $this->options['adapter'] . 'Schema';
            if (class_exists($class)) {
                $this->schema = new $class($this->getAdapter());
            } else {
                throw new DbException('Schema is not exist:' . $class);
            }
        }
        return $this->schema;
    }
645224
public function getSchema()
    {
        if (!isset($this->_schema)) {
            $this->_schema = $this->loadSchemata();
        }
        return $this->_schema;
    }
314703
public String getRecordSchema() throws IOException {
        Schema schema = getInputPathAvroSchema();
        String recSchema = schema.toString();
        return recSchema;
    }