Use la búsqueda de texto completo de Oracle en Entity Framework

Índice

Introducción

La base de datos de Oracle admite una función avanzada de búsqueda de texto completo (FTS) llamada Texto de oráculoque se describe exhaustivamente en la documentación:

Decidimos satisfacer las necesidades de nuestros usuarios que desean aprovechar la búsqueda de texto completo en Entity Framework e implementamos Texto de oráculo funcionalidad de nuestro proveedor Devart dotConnect para Oracle ADO.NET Entity Framework.
Trabajar con Texto de oráculo nuevas funciones en las consultas de LINQ to Entities OracleTextFunctionsOracleTextFunctions usó la clase que está en Devart.Data.Oracle.Entity.dll montaje. Esto le permite trabajar con tales Texto de oráculo funciona como:

  • Contiene
  • CONSIDERACIÓN
  • CONFIADO
  • DEDUCCIÓN
  • MATCH_SCORE

Llamar Texto de oráculo procedimientos almacenados específicos del paquete CTX_DDL, Paquete OracleCtxDdl usó la clase que está en Devart.Data.Oracle.Entity.dll montaje.
Para configurar las migraciones de Code-First para su creación y eliminación Texto de oráculo indicadores específicos, arte CreateIndexConfigurationCreateIndexConfiguration y DropIndexConfigurationDropIndexConfiguration clases usadas que se encuentran en el Devart.Data.Oracle.Entity.Migrations.dll montaje.
Este artículo trata sobre lo siguiente:

revisión de libros de texto

En este tutorial aprenderá a crear una aplicación que utilizará las siguientes tecnologías:

Siga el enlace al final de este artículo para descargar la aplicación de muestra completa.
Aunque en este ejemplo mostramos trabajar con Code-First, Texto de oráculo Las consultas se pueden escribir de manera similar para el mapeo XML regular utilizando modelos EDMX/EDML desarrollados como parte de los enfoques de base de datos primero o modelo primero. Por lo tanto, también revisaremos brevemente el enfoque de base de datos primero en este tutorial.
Decidimos tomar como base el libro de texto estándar de Oracle, está disponible en la sección "Primeros pasos con Oracle Text".

requisitos previos

Preconfigurar la base de datos y el modelo como parte del enfoque de la base de datos

1. Cree un proyecto de consola C# en Visual Studio 2010 SP1 y asígnele el nombre OracleFullTextSearch.
2. En el proyecto, agregue enlaces a las siguientes compilaciones:

  • Devart.Datos;
  • Devart.Data.Oracle;
  • Devart.Data.Oracle.Entidad;
  • Devart.Data.Oracle.Entity.Migrations.

3. También se requiere un usuario de Oracle que tenga un rol CTXAPP y una concesión EXECUTE para paquetes CTXSYS.
Una forma de crear dicho usuario es ejecutar las siguientes declaraciones de Oracle con cualquier herramienta diseñada para trabajar con la base de datos de Oracle:

CREATE USER myuser IDENTIFIED BY myuser_password;
GRANT RESOURCE, CONNECT, CTXAPP TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_CLS TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_DDL TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_DOC TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_OUTPUT TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_QUERY TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_REPORT TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_THES TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_ULEXER TO myuser;

4. Cree un modelo de Entity Framework vacío para este usuario a través de Entity Developer. У Líder de decisión ventana, llame al menú contextual del proyecto, luego seleccione Agregar -> Nuevo elemento -> Modelo de esencia de Devart. Siga las instrucciones del asistente y especifique una cadena de conexión válida. El archivo del modelo y el código generado se agregarán al proyecto.

Preconfigure la base de datos y el modelo de acuerdo con el enfoque Code-First

1. Cree un proyecto de consola C# en Visual Studio 2010 SP1 y asígnele el nombre OracleFullTextSearch.
2. En el proyecto, agregue enlaces a las siguientes compilaciones:

  • Entidad.de.datos.del.sistema;
  • Devart.Datos;
  • Devart.Data.Oracle;
  • Devart.Data.Oracle.Entidad;
  • Devart.Data.Oracle.Entity.Migrations.

3. Para ejecutar esto, agregue la última versión pública de EF Code-First a su proyecto Consola del administrador de paquetes a través del menú de Visual Studio: Herramientas -> Administrador de paquetes de biblioteca -> Consola del administrador de paquetes, y en la ventana que aparece, ejecute el siguiente comando:

Install-Package EntityFramework

Como resultado, la compilación EntityFramework.dll se agrega al proyecto, complementada con entradas de App.config, y se crea el archivo packages.config.
4. Agregar uno nuevo MiContexto.cs archivo en el proyecto y poner en él un modelo vacío:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.Entity;
using Devart.Data.Oracle;
using Devart.Data.Oracle.Entity;
using Devart.Data.Oracle.Entity.Configuration;

namespace OracleFullTextSearch {

  public class MyContext: DbContext {

    private OracleCtxDdlPackage ctxDdl;

    public MyContext() {
    }

    public MyContext(OracleConnection connection)
      : base(connection, false) {
    }

    static MyContext() {

      var config = Devart.Data.Oracle.Entity.Configuration.OracleEntityProviderConfig.Instance;
      config.Workarounds.DisableQuoting = true;
      config.CodeFirstOptions.UseNonUnicodeStrings = true;
    }

    public OracleCtxDdlPackage CtxDdl {
      get {
        if (this.ctxDdl == null)
          this.ctxDdl = new OracleCtxDdlPackage((OracleConnection)Base de datos.Connection);
        return this.ctxDdl;
      }
    }

    protected override void OnModelCreating(DbModelBuilder modelBuilder) {

    }

  }
}

Aquí, para no sobrecargar la muestra con comillas, también establecemos Deshabilitar cita El valor del parámetro de configuración del proveedor de EF es True para obtener ID de DDL y DML sin comillas durante la generación de SQL. En los programas personalizados, esto es opcional.
Asimismo, establecimos Usar cadenas no Unicode valor del parámetro en True para evitar especificar explícitamente un tipo de datos de cadena [Column(TypeName=”varchar2″)] para las propiedades de la cadena de objetos, especifique solo la restricción de longitud [MaxLength(200)] seria suficiente.
También hemos agregado una propiedad CtxDdl de tipo OracleCtxDdlPackage para trabajar con procedimientos guardados del paquete CTX_DDL.
5. Ejecute el siguiente comando en Consola del administrador de paquetes:

Enable-Migrations

Como resultado, Configuración Clase añadida al proyecto.
6. Complementar lo existente Configuración diseñador de clases

    public Configuration()
    {
      AutomaticMigrationsEnabled = false;
    }

especificando el generador de SQL:

    public Configuration()
    {
      AutomaticMigrationsEnabled = false;

      SetSqlGenerator(Devart.Data.Oracle.Entity.Migrations.OracleConnectionInfo.InvariantName,
              new Devart.Data.Oracle.Entity.Migrations.OracleEntityMigrationSqlGenerator());
    }

7. También se requiere un usuario de Oracle que tenga un rol CTXAPP y una concesión EXECUTE para paquetes CTXSYS.
Para crear dicho usuario, puede, por ejemplo, ejecutar las siguientes declaraciones de Oracle utilizando cualquier herramienta diseñada para trabajar con la base de datos de Oracle:

CREATE USER myuser IDENTIFIED BY myuser_password;
GRANT RESOURCE, CONNECT, CTXAPP TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_CLS TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_DDL TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_DOC TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_OUTPUT TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_QUERY TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_REPORT TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_THES TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_ULEXER TO myuser;

8. Configurando una cadena de conexión para nuestra clase mi contexto el modelo se ejecutará en el archivo de configuración de la aplicación. Agregar una cadena de conexión a Aplicación.config Archivo:

<connectionStrings>
  <add name="MyContext" connectionString="User Id=myuser;Password=myuser_password;Server=ORA;" providerName="Devart.Data.Oracle" />
</connectionStrings>

Uso del índice CONTEXT

Preconfigurar la base de datos y el modelo como parte del enfoque de la base de datos

1. Crear DOCUMENTOS mesa y IDX_DOCS Índice de contexto.

CREATE TABLE docs (
  id NUMBER PRIMARY KEY,
  text VARCHAR2(200)
);

CREATE INDEX idx_docs ON docs(text)
     INDEXTYPE IS CTXSYS.CONTEXT PARAMETERS
     ('FILTER CTXSYS.NULL_FILTER SECTION GROUP CTXSYS.HTML_SECTION_GROUP');

2. Usar Actualizar asistente desde la base de datos agregar DOCUMENTOS tabla al modelo EF.

Preconfigure la base de datos y el modelo de acuerdo con el enfoque Code-First

1. Agregar doc.cs archivo de proyecto:

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text;

namespace OracleFullTextSearch {

  public class Doc {

    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.None)]
    public int Id { get; set; }

    [MaxLength(200)]
    public string Text { get; set; }

  }
}

Aquí mostramos que la propiedad Id es la clave principal, pero su valor no será generado por el servidor.
Para la propiedad Texto, establecemos el tipo de datos en VARCHAR (200).
2. Agregue la siguiente línea a mi contexto clase:

    public DbSet<Doc> Docs { get; set; }

3. Para crear una migración, ejecute el siguiente comando Consola del administrador de paquetes:

Add-Migration AddDoc

Como resultado, se agrega una clase de migración al proyecto con el siguiente contenido:

    public partial class AddDoc : DbMigration
    {
        public override void Up()
        {
            CreateTable(
                "Docs",
                c => new
                    {
                        Id = c.Int(nullable: false),
                        Text = c.String(maxLength: 200, unicode: false),
                    })
                .PrimaryKey(t => t.Id);

        }

        public override void Down()
        {
            DropTable("Docs");
        }
    }

4. Complete la migración con comandos para crear (y eliminar) el archivo CTXSYS.CONTEXTO índice:

    using Devart.Data.Oracle.Entity.Migrations;

    public partial class AddDoc : DbMigration
    {
        public override void Up()
        {
            CreateTable(
                "Docs",
                c => new
                    {
                        Id = c.Int(nullable: false),
                        Text = c.String(maxLength: 200, unicode: false),
                    })
                .PrimaryKey(t => t.Id);

            CreateIndex(
              table: "Docs",
              column: "Text",
              name: "idx_docs",
              anonymousArguments: new OracleCreateIndexConfiguration() {
                CtxIndexType = CtxIndexType.Context,
                CtxParameters = "FILTER CTXSYS.NULL_FILTER SECTION GROUP CTXSYS.HTML_SECTION_GROUP"
              });
        }

        public override void Down()
        {
            DropIndex(table: "Docs", name: "idx_docs");
            DropTable("Docs");
        }
    }

5. Actualice la base de datos mediante la migración ejecutando el siguiente comando Consola del administrador de paquetes:

Update-Base de datos -Verbose

Como resultado, se ejecutarán comandos para crear objetos modelo.

CREATE TABLE Docs ( 
  Id NUMBER(10) NOT NULL,
  Text VARCHAR2(200 CHAR) NULL,
  PRIMARY KEY (Id)
)

CREATE INDEX idx_docs ON Docs (Text) INDEXTYPE IS CTXSYS.CONTEXT PARAMETERS ('FILTER CTXSYS.NULL_FILTER SECTION GROUP CTXSYS.HTML_SECTION_GROUP')

También se ejecutarán comandos para crear la tabla del sistema MigrationHistory y llenarla con datos de migración.

Ejemplo de búsqueda de texto completo usando las funciones CONTAINS y SCORE

En este tutorial, hemos habilitado OracleMonitor para ver sentencias DDL y DML ejecutables en la aplicación Devart dbMonitor. Sin embargo, tenga en cuenta que es posible usar OracleMonitor para probar y depurar, pero debe estar limitado en el entorno de producción, ya que el monitoreo puede reducir el rendimiento de su aplicación.
Para usar el monitoreo, agregue este código a su programa

var monitor = new OracleMonitor() { IsActive = true };

y ejecute dbMonitor.
Escribamos código que llene la tabla con datos, actualice el índice y genere consultas usando Contiene y DEDUCCIÓN funciones

using (var ctx = new MyContext()) {

  // Load documents into the DOCS table
  ctx.Docs.Add(new Doc() { Id = 1, Text = "California is a state in the US." });
  ctx.Docs.Add(new Doc() { Id = 2, Text = "Paris is a city in France." });
  ctx.Docs.Add(new Doc() { Id = 3, Text = "France is in Europe." });
  ctx.SaveChanges();

  // Synchronize the index
  ctx.CtxDdl.SyncIndex("IDX_DOCS", "2M");

  // Querying your table with CONTAINS
  // Write a LINQ to Entities analogue for the SQL query:
  // SELECT SCORE(1), id, text FROM docs WHERE CONTAINS(text, 'France', 1) > 0
  var firstQuery = ctx.Docs
    .Where(doc => OracleTextFunctions.Contains(doc.Text, "France", 1) > 0)
    .Select(doc => new {
      Score = OracleTextFunctions.Score(1),
      Doc = doc
    });
  var firstQueryResults = firstQuery.ToList();

  // Output:
  Console.WriteLine("1) CONTAINS('France')");
  foreach (var item in firstQueryResults)
    Console.WriteLine("{0,-5} | {1,-5} | {2}", item.Score, item.Doc.Id, item.Doc.Text);

  // Add some rows to the DOCS table
  ctx.Docs.Add(new Doc() { Id = 4, Text = "Los Angeles is a city in California." });
  ctx.Docs.Add(new Doc() { Id = 5, Text = "Mexico City is big." });
  ctx.SaveChanges();

  // Write a LINQ to Entities analogue for the SQL query:
  //   SELECT SCORE(1), id, text FROM docs WHERE CONTAINS(text, 'city', 1) > 0
  var secondQuery = ctx.Docs
    .Where(doc => OracleTextFunctions.Contains(doc.Text, "city", 1) > 0)
    .Select(doc => new {
      Score = OracleTextFunctions.Score(1),
      Doc = doc
    });
  var secondQueryResults = secondQuery.ToList();

  // Output:
  Console.WriteLine();
  Console.WriteLine("2) CONTAINS('city')");
  foreach (var item in secondQuery)
    Console.WriteLine("{0,-5} | {1,-5} | {2}", item.Score, item.Doc.Id, item.Doc.Text);

  // Synchronize the index
  ctx.CtxDdl.SyncIndex("IDX_DOCS", "2M");

  // Execute the 2nd query once again
  var secondQueryNewResults = secondQuery.ToList();

  // Output:
  Console.WriteLine();
  Console.WriteLine("3) CONTAINS('city') after index synchronization");
  foreach (var item in secondQuery)
    Console.WriteLine("{0,-5} | {1,-5} | {2}", item.Score, item.Doc.Id, item.Doc.Text);
}

Uso del índice CTXCAT

Preconfigurar la base de datos y el modelo como parte del enfoque de la base de datos

1. Crear SUBASTA mesa, st SUBASTA_ISET conjunto de índices y SUBASTA_TITLEX Índice CTXCAT.

CREATE TABLE auction(
  item_id NUMBER,
  title VARCHAR2(100),
  category_id NUMBER,
  price NUMBER,
  bid_close DATE
);

EXEC CTX_DDL.CREATE_INDEX_SET('auction_iset');

EXEC CTX_DDL.ADD_INDEX('auction_iset','price');

CREATE INDEX auction_titlex ON AUCTION(title) INDEXTYPE IS CTXSYS.CTXCAT PARAMETERS ('index set auction_iset');

2. Usar Actualizar asistente desde la base de datos agregar SUBASTA tabla al modelo EF.

Preconfigure la base de datos y el modelo de acuerdo con el enfoque Code-First

1. Agregar Subasta.cs archivo de proyecto:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel.DataAnnotations;

namespace OracleFullTextSearch {

  [Table("auction")]
  public class Auction {

    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.None)]
    [Column("item_id")]
    public int Id { get; set; }

    [MaxLength(100)]
    public string Title { get; set; }

    [Column("category_id")]
    public int CategoryId { get; set; }

    public decimal Price { get; set; }

    [Column("bid_close")]
    public DateTime BidClose { get; set; }

  }
}

2. Agregue la siguiente línea a mi contexto clase:

  public DbSet<Auction> Auctions { get; set; }

3. Para crear una migración, ejecute el siguiente comando Consola del administrador de paquetes:

Add-Migration AddAuction

Como resultado, se agrega una clase de migración al proyecto con el siguiente contenido:

    public partial class AddAuction : DbMigration
    {
        public override void Up()
        {
            CreateTable(
                "auction",
                c => new
                    {
                        item_id = c.Int(nullable: false),
                        Title = c.String(maxLength: 100, unicode: false),
                        category_id = c.Int(nullable: false),
                        Price = c.Decimal(nullable: false, precision: 18, scale: 2),
                        bid_close = c.DateTime(nullable: false),
                    })
                .PrimaryKey(t => t.item_id);

        }

        public override void Down()
        {
            DropTable("auction");
        }
    }

4. Complete la migración con comandos para crear (y eliminar) el archivo CTXSYS.CTXCAT índice y conjunto de índices correspondiente:

    using Devart.Data.Oracle.Entity.Migrations;

    public partial class AddAuction : DbMigration
    {
        public override void Up()
        {
            CreateTable(
                "auction",
                c => new
                    {
                        item_id = c.Int(nullable: false),
                        Title = c.String(maxLength: 100, unicode: false),
                        category_id = c.Int(nullable: false),
                        Price = c.Decimal(nullable: false, precision: 18, scale: 2),
                        bid_close = c.DateTime(nullable: false),
                    })
                .PrimaryKey(t => t.item_id);

            CreateIndex("auction",
                    "Title",
                    name: "auction_titlex",
                    anonymousArguments: new OracleCreateIndexConfiguration() {
                      CtxIndexType = CtxIndexType.CtxCat,
                      CtxIndexSet = "auction_iset",
                      CtxIndexSetColumns = "price"
                    });
        }

        public override void Down()
        {
            DropIndex(table: "auction", name: "auction_titlex",
                  anonymousArguments: new OracleDropIndexConfiguration() {
                    Force = true,
                    CtxIndexSet = "auction_iset"
                  });

            DropTable("auction");
        }
    }

5. Actualice la base de datos mediante la migración ejecutando el siguiente comando Consola del administrador de paquetes:

Update-Base de datos -Verbose

El resultado son comandos para crear objetos modelo.

CREATE TABLE auction ( 
  item_id NUMBER(10) NOT NULL,
  Title VARCHAR2(100 CHAR) NULL,
  category_id NUMBER(10) NOT NULL,
  Price NUMBER(18,2) NOT NULL,
  bid_close TIMESTAMP(7) NOT NULL,
  PRIMARY KEY (item_id)
);

BEGIN
  CTX_DDL.CREATE_INDEX_SET('auction_iset');
  CTX_DDL.ADD_INDEX('auction_iset', 'price');
END;

CREATE INDEX auction_titlex ON auction (Title) INDEXTYPE IS CTXSYS.CTXCAT PARAMETERS ('INDEX SET auction_iset');

y se ejecutará un comando para completar la tabla del sistema HistoryTable con los datos de migración implementados.

Ejemplo de búsqueda de texto completo con la función CATSEARCH

Escribamos el código que llena SUBASTA tabla de datos y formación Texto de oráculo solicitudes utilizando CONSIDERACIÓN función. No es necesario actualizar el índice, obviamente, ya que CTXCAT el índice se actualiza automáticamente.

using (var ctx = new MyContext()) {

  // Pupulate the AUCTION table
  ctx.Auctions.Add(new Auction { Id = 1, Title = "NIKON CAMERA", CategoryId = 1, Price = 400, BidClose = new DateTime(2002, 10, 24) });
  ctx.Auctions.Add(new Auction { Id = 2, Title = "OLYMPUS CAMERA", CategoryId = 1, Price = 300, BidClose = new DateTime(2002, 10, 25) });
  ctx.Auctions.Add(new Auction { Id = 3, Title = "PENTAX CAMERA", CategoryId = 1, Price = 200, BidClose = new DateTime(2002, 10, 26) });
  ctx.Auctions.Add(new Auction { Id = 4, Title = "CANON CAMERA", CategoryId = 1, Price = 250, BidClose = new DateTime(2002, 10, 27) });
  ctx.SaveChanges();

  // Querying your table with CATSEARCH
  // Write a LINQ to Entities analogue for the SQL query:
  //   SELECT title, price FROM auction WHERE CATSEARCH(title, 'CAMERA', 'order by price') > 0;
  var firstQuery = ctx.Auctions
    .Where(a => OracleTextFunctions.Catsearch(a.Title, "CAMERA", "order by price") > 0)
    .Select(a => new { a.Title, a.Price });
  var firstQueryResults = firstQuery.ToList();

  // Output
  Console.WriteLine("1) order by price");
  foreach (var item in firstQueryResults)
    Console.WriteLine("{0,-20} | {1}", item.Title, item.Price);

  // Write a LINQ to Entities analogue for the SQL query:
  //   SELECT title, price FROM auction WHERE CATSEARCH(title, 'CAMERA', 'price <= 300') > 0;
  var secondQuery = ctx.Auctions
    .Where(a => OracleTextFunctions.Catsearch(a.Title, "CAMERA", "price <= 300") > 0)
    .Select(a => new { a.Title, a.Price });
  var secondQueryResults = secondQuery.ToList();

  // Output
  Console.WriteLine();
  Console.WriteLine("2) price <= 300");
  foreach (var item in secondQueryResults)
    Console.WriteLine("{0,-20} | {1}", item.Title, item.Price);

  // Add some rows to the DOCS table
  ctx.Auctions.Add(new Auction { Id = 5, Title = "FUJI CAMERA", CategoryId = 1, Price = 350, BidClose = new DateTime(2002, 10, 28) });
  ctx.Auctions.Add(new Auction { Id = 6, Title = "SONY CAMERA", CategoryId = 1, Price = 310, BidClose = new DateTime(2002, 10, 28) });
  ctx.SaveChanges();

  // Execute the 1st query once again
  var firstQueryNewResults = firstQuery.ToList();

  // Output
  Console.WriteLine();
  Console.WriteLine("3) order by price (after adding new records)");
  foreach (var item in firstQueryNewResults)
    Console.WriteLine("{0,-20} | {1}", item.Title, item.Price);
}

Uso del índice CTXRULE

Preconfigurar la base de datos y el modelo como parte del enfoque de la base de datos

1. Crear CERRADO mesa y REGLA CTX índice para su columna

CREATE TABLE queries (
  query_id      NUMBER,
  query_string  VARCHAR2(80)
);

CREATE INDEX queryx ON queries(query_string) INDEXTYPE IS CTXSYS.CTXRULE;

2. Usar Actualizar asistente desde la base de datos agregar CERRADO tabla al modelo EF.

Preconfigure la base de datos y el modelo de acuerdo con el enfoque Code-First

1. Agregar Consulta.cs archivo de proyecto:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel.DataAnnotations;

namespace OracleFullTextSearch {

  public class Query {

    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.None)]
    [Column("query_id")]
    public int Id { get; set; }

    [Column("query_string")]
    [MaxLength(80)]
    public string QueryString { get; set; }

  }
}

2. Agregue la siguiente línea a mi contexto clase:

public DbSet<Query> Queries { get; set; }

3. Cree una migración ejecutando el siguiente comando Consola del administrador de paquetes:

Add-Migration AddQuery

Como resultado, se agrega una clase de migración al proyecto con el siguiente contenido:

    public partial class AddQuery : DbMigration
    {
        public override void Up()
        {
            CreateTable(
                "Queries",
                c => new
                    {
                        query_id = c.Int(nullable: false),
                        query_string = c.String(maxLength: 80, unicode: false),
                    })
                .PrimaryKey(t => t.query_id);

        }

        public override void Down()
        {
            DropTable("Queries");
        }
    }

4. Complete la migración con comandos para crear (y eliminar) el archivo CTXSYS.CTXRULE índice:

    using Devart.Data.Oracle.Entity.Migrations;

    public partial class AddQuery : DbMigration
    {
        public override void Up()
        {
            CreateTable(
                "Queries",
                c => new
                    {
                        query_id = c.Int(nullable: false),
                        query_string = c.String(maxLength: 80, unicode: false),
                    })
                .PrimaryKey(t => t.query_id);

            CreateIndex(
                table: "Queries",
                column: "query_string",
                name: "queryx",
                anonymousArguments: new OracleCreateIndexConfiguration() {
                  CtxIndexType = CtxIndexType.CtxRule
                });
        }

        public override void Down()
        {
            DropIndex(table: "Queries", name: "queryx");
            DropTable("Queries");
        }
    }

5. Actualice la base de datos mediante la migración ejecutando el siguiente comando Consola del administrador de paquetes:

Update-Base de datos -Verbose

El resultado son comandos para crear objetos modelo.

CREATE TABLE Queries ( 
  query_id NUMBER(10) NOT NULL,
  query_string VARCHAR2(80 CHAR) NULL,
  PRIMARY KEY (query_id)
);

CREATE INDEX queryx ON Queries (query_string) INDEXTYPE IS CTXSYS.CTXRULE;

y se ejecutará un comando para completar la tabla del sistema HistoryTable con los datos de migración implementados.

Ejemplo de búsqueda de texto completo usando la función COINCIDIR

Escribamos código que llene la tabla con datos, actualice el índice y genere consultas usando CONFIADO función.

using (var ctx = new MyContext()) {

  // Load documents into the QUERIES table
  ctx.Queries.Add(new Query() { Id = 1, QueryString = "oracle" });
  ctx.Queries.Add(new Query() { Id = 2, QueryString = "larry or ellison" });
  ctx.Queries.Add(new Query() { Id = 3, QueryString = "oracle and text" });
  ctx.Queries.Add(new Query() { Id = 4, QueryString = "market share" });
  ctx.SaveChanges();

  // Synchronize the index
  ctx.CtxDdl.SyncIndex("QUERYX", "2M");

  // Classify with MATCHES
  // Write a LINQ to Entities analogue for the SQL query:
  //   SELECT query_id,query_string FROM queries WHERE MATCHES(query_string,
  //     'Oracle announced that its market share in databases increased over the last year.') > 0;
  var firstQuery = ctx.Queries
    .Where(q => OracleTextFunctions.Matches(q.QueryString, "Oracle announced that its market share in databases increased over the last year.") > 0);
  var firstQueryResults = firstQuery.ToList();

  // Output:
  Console.WriteLine("Classify with MATCHES");
  Console.WriteLine();
  foreach (var item in firstQueryResults)
    Console.WriteLine("{0,-10} | {1}", item.Id, item.QueryString);
}

Conclusión

Así que te mostramos cómo usar Texto de oráculo Funcionalidad de la aplicación Entity Framework, incluido un proceso de desarrollo basado en Code-First Migrations. Esperamos saber de usted a través de comentarios, el foro de Entity Framework y nuestro formulario de contacto si necesita rediseñar o mejorar el soporte. Texto de oráculo de nuestro proveedor.

Puede descargar el archivo con la muestra completa de este tutorial aquí.

Artículos de interés

Subir