name: OSV-Scanner Scheduled Scan

on:
  schedule:
    - cron: 0 4 * * 1

permissions:
  # Require writing security events to upload SARIF file to security tab
  security-events: write
  # Only need to read contents
  contents: read

jobs:
  scan-scheduled:
    if: github.repository == 'tensorflow/tensorflow'

  cancel-in-progress: false

env:
  # Set the DEVELOCITY_ACCESS_KEY so that a Build Scan is generated
  DEVELOCITY_ACCESS_KEY: ${{ secrets.DEVELOCITY_ACCESS_KEY }}
  # Enable debug for the `gradle-build-action` cache operations
  GRADLE_BUILD_ACTION_CACHE_DEBUG_ENABLED: true

permissions: {}

jobs:

    // manifest with Class-Path pointing to jar2, we won't scan jar2 twice.
    Set<File> scanned = new HashSet<>();
    for (LocationInfo location : locations) {
      scanned.add(location.file());
    }

    // Scan all locations
    ImmutableSet.Builder<ResourceInfo> builder = ImmutableSet.builder();
    for (LocationInfo location : locations) {

	var name string
	if err := rawSQLUserRow.Scan(&name); err != nil {
		t.Fatalf("rawSQLUserRow scan failed: %v", err)
	}
	if name != user.Name {
		t.Errorf("expected %s, got %s", user.Name, name)
	}

	var scannedUserName string
	selectUserRow := gorm.G[User](DB).Select("name").Where("name = ?", user.Name).Row(ctx)
	if err := selectUserRow.Scan(&scannedUserName); err != nil {

                        }
                        extensions.findByType<DevelocityTestConfiguration>()?.apply {
                            // PTS doesn't work well with architecture tests which scan all classes
                            predictiveTestSelection.enabled = false
                        }
                    }
                }
            }
        }
    }
}

# Develocity integration
platforms/enterprise/                                   @gradle/bt-build-scan
platforms/enterprise/enterprise/                        @gradle/bt-build-scan @gradle/dv-acceleration-team
platforms/enterprise/enterprise-logging/                @gradle/bt-build-scan @gradle/dv-acceleration-team

# JVM platform
platforms/jvm/                                      @gradle/bt-jvm

}

// GetTables returns tables
func (m Migrator) GetTables() (tableList []string, err error) {
	err = m.DB.Raw("SELECT TABLE_NAME FROM information_schema.tables where TABLE_SCHEMA=?", m.CurrentDatabase()).
		Scan(&tableList).Error
	return
}

// CreateTable create table in database for values
func (m Migrator) CreateTable(values ...interface{}) error {
	for _, value := range m.ReorderModels(values, false) {

     * Handler classes in subpackages and registering them as web or file protocols
     * based on their PROTOCOL_TYPE field.
     *
     * @param basePackage the base package to scan for protocol handlers
     */
    protected void loadProtocols(final String basePackage) {
        final List<String> subPackages = new ArrayList<>();
        final String path = basePackage.replace('.', '/');

	return os.Getenv("GORM_DIALECT") == "mysql"
}

func mysqlVersionAtLeast(major, minor int) bool {
	if !isMysql() {
		return false
	}

	var version string
	if err := DB.Raw("SELECT VERSION()").Row().Scan(&version); err != nil {
		return false
	}

	base := strings.SplitN(strings.TrimSpace(version), "-", 2)[0]
	parts := strings.Split(base, ".")
	if len(parts) < 2 {
		return false
	}

type SetCreateOrUpdateInterface[T any] interface {
	Create(ctx context.Context) error
	Update(ctx context.Context) (rowsAffected int, err error)
}

type ExecInterface[T any] interface {
	Scan(ctx context.Context, r interface{}) error
	First(context.Context) (T, error)
	Last(ctx context.Context) (T, error)
	Take(context.Context) (T, error)
	Find(ctx context.Context) ([]T, error)