CoreLib supports multiple logging frameworks. Configure your preferred logger:

```java
// Use with SLF4J (add slf4j-api dependency)
Logger logger = Logger.getLogger(MyClass.class);

// Use with Commons Logging (add commons-logging dependency)  
Logger logger = Logger.getLogger(MyClass.class);

// Use with Java Util Logging (built-in)
Logger logger = Logger.getLogger(MyClass.class.getName());
```

  require(address.size == 4)
  return Buffer()
    .writeDecimalLong((address[0] and 0xff).toLong())
    .writeByte('.'.code)
    .writeDecimalLong((address[1] and 0xff).toLong())
    .writeByte('.'.code)
    .writeDecimalLong((address[2] and 0xff).toLong())
    .writeByte('.'.code)
    .writeDecimalLong((address[3] and 0xff).toLong())
    .readUtf8()
}

/**

  }

  override fun readTimeoutMillis(): Int = readTimeoutMillis

  override fun withReadTimeout(
    timeout: Int,
    unit: TimeUnit,
  ): Interceptor.Chain {
    check(exchange == null) { "Timeouts can't be adjusted in a network interceptor" }

    return copy(readTimeoutMillis = checkDuration("readTimeout", timeout.toLong(), unit))
  }

		},
		{
			Name: "idx_user_indices_name8",
			Type: "",
			Fields: []schema.IndexOption{
				{Field: &schema.Field{Name: "Name8"}, Length: 10},
				// Note: Duplicate Columns
				{Field: &schema.Field{Name: "Name8"}, Collate: "utf8"},
			},
		},
		{
			Class:  "UNIQUE",
			Name:   "idx_user_indices_idx_compname_1",
			Option: "NULLS NOT DISTINCT",

        }

        toWrite = minOf(byteCount, writeBytesMaximum - writeBytesTotal).toInt()
        toWrite = minOf(toWrite, writer.maxDataLength())
        writeBytesTotal += toWrite.toLong()
      }

      byteCount -= toWrite.toLong()
      writer.data(outFinished && byteCount == 0L, streamId, buffer, toWrite)
    }
  }

  internal fun writeSynResetLater(
    streamId: Int,
    errorCode: ErrorCode,
  ) {

            final Class<?> clazz = Class.forName("org.apache.commons.httpclient.MultiThreadedHttpConnectionManager");
            final Method method = clazz.getMethod("shutdownAll", (Class<?>[]) null);
            method.invoke(null, (Object[]) null);
        } catch (final ClassNotFoundException e) {
            // ignore
        } catch (final Exception e) {
            logger.warn("Could not shutdown Commons HttpClient.", e);
        }
    }

	if len(defaultUpdatingColumns) > 0 || stmt.DB.FullSaveAssociations {
		onConflict.Columns = make([]clause.Column, 0, len(s.PrimaryFieldDBNames))
		for _, dbName := range s.PrimaryFieldDBNames {
			onConflict.Columns = append(onConflict.Columns, clause.Column{Name: dbName})
		}

		onConflict.UpdateAll = stmt.DB.FullSaveAssociations
		if !onConflict.UpdateAll {

    Ao ter o tipo como `int | None`, o SQLModel saberá que essa coluna deve ser um `INTEGER` no banco de dados SQL e que ela deve ser `NULLABLE`.

* `Field(index=True)` informa ao SQLModel que ele deve criar um **índice SQL** para essa coluna, o que permitirá buscas mais rápidas no banco de dados ao ler dados filtrados por essa coluna.

    O SQLModel saberá que algo declarado como `str` será uma coluna SQL do tipo `TEXT` (ou `VARCHAR`, dependendo do banco de dados).

		</dependency>
		<dependency>
			<groupId>commons-codec</groupId>
			<artifactId>commons-codec</artifactId>
			<version>${commons.codec.version}</version>
		</dependency>
		<dependency>
			<groupId>commons-io</groupId>
			<artifactId>commons-io</artifactId>
			<version>${commons.io.version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>

				clause.Or(clause.Gt{Column: "score", Value: 100}, clause.Like{Column: "name", Value: "%linus%"}),
			}},
			clause.GroupBy{Columns: []clause.Column{{Name: "role"}}, Having: []clause.Expression{clause.Eq{"role", "admin"}}},
			clause.Limit{Limit: &limit10, Offset: 20},
			clause.OrderBy{Columns: []clause.OrderByColumn{{Column: clause.PrimaryColumn, Desc: true}}},
		}

		for _, clause := range clauses {
			stmt.AddClause(clause)
		}