}

func TestToSQL(t *testing.T) {
	// By default DB.DryRun should false
	if DB.DryRun {
		t.Fatal("Failed expect DB.DryRun to be false")
	}

	if DB.Dialector.Name() == "sqlserver" {
		t.Skip("Skip SQL Server for this test, because it too difference with other dialects.")
	}

	date, _ := time.ParseInLocation("2006-01-02", "2021-10-18", time.Local)

	// find
	sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB {

  // after the legalize below, for now it needs to be below the above passes
  // that work on TF dialect and before inliner so that the function calls in
  // body and cond are inlined for optimization.
  pass_manager->addPass(mlir::TFL::CreateLegalizeTFWhilePass());

  // Add function inlining pass. Both TF and TFLite dialects are opted into
  // function inliner interface.
  pass_manager->addPass(mlir::createInlinerPass());

"""Base test class for quantize_model Tests."""

from typing import List, Mapping, Optional, Sequence, Tuple

from absl.testing import parameterized
from mlir import ir
from mlir.dialects import stablehlo as stablehlo_dialect
import numpy as np
import tensorflow  # pylint: disable=unused-import

from tensorflow.compiler.mlir.stablehlo import stablehlo
from tensorflow.python.eager import def_function

  let summary = "Transform from TF control dialect to TF executor dialect.";
  let constructor = "CreateBreakUpIslandsPass()";
  let dependentDialects = ["mlir::tf_executor::TensorFlowExecutorDialect"];
}

def SplitIntoIslandPerOpPass : Pass<"tf-executor-split-into-island-per-op", "mlir::func::FuncOp"> {
  let summary = "Transform from TF control dialect to TF executor dialect.";
  let description = [{

// consider matches for this language. This corresponds to the idea that most
// users have a strong preference for the first defined language. A user can
// still prefer a second language over a dialect of the preferred language by
// explicitly specifying dialects, e.g. "en, nl, en-GB". In this case pin should
// be false.
func (m *bestMatch) update(have *haveTag, tag language.Tag, maxScript language.Script, maxRegion language.Region, pin bool) {

pass for now, but should be integrated with some notion of "target" in the
MLIR pipeline in the future.
### `-tf-group-by-dialect`

_Groups ops into functions that only contain one dialect._

Factors operations into subroutines such that all functions only
contain a single dialect. Which of the dialects are allowed in the
"top" function is configurable.

For example, the code
  x.a()
  x.b()
  %c = y.c()

  }
  // Attempt dialect fallback if op's fold hook failed.
  if (failed(folded)) {
    Dialect* dialect = op->getDialect();
    if (!dialect) return failure();
    // Only attempt TF dialect fallback if there are no unknown operands.
    if (some_unknown && dialect == tf_dialect_) return failure();
    auto* interface = dialect->getRegisteredInterface<DialectFoldInterface>();

                                    can support POSIX, PCRE or any other dialects
                                    of regular expressions. Please read the implementation's
                                    documentation to determine the supported dialect."
                                  enum:
                                  - Exact

                      std::pair<uint64_t, uint64_t>>
      custom_op_idx_map_;

  // Points to TensorFlow and TFLite dialects, respectively. nullptr if the
  // dialect is not registered.
  const Dialect* tf_dialect_;
  const Dialect* tfl_dialect_;
  const Dialect* vhlo_dialect_;

  // The failed ops during legalization.
  std::map<std::string, std::set<std::string>> failed_flex_ops_;

// Declare passes used in xla_legalize_tf.

include "mlir/Pass/PassBase.td"

def LegalizeTF : Pass<"xla-legalize-tf", "ModuleOp"> {
  let summary = "Legalize from TF dialect's or HLO dialect's control flow.";

  let description = [{
    Legalizes from TF dialect to HLO dialect. When allow_partial_conversion is
    false, emits an error if there is any operation that can't be legalized.