All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • info.archinnov.achilles.generated.manager.EntityWithImplicitFieldParsing_Manager Maven / Gradle / Ivy

    The newest version!
    package info.archinnov.achilles.generated.manager;

import com.datastax.driver.core.BoundStatement;
import com.datastax.driver.core.PreparedStatement;
import com.datastax.driver.core.RegularStatement;
import info.archinnov.achilles.generated.dsl.EntityWithImplicitFieldParsing_Delete;
import info.archinnov.achilles.generated.dsl.EntityWithImplicitFieldParsing_Select;
import info.archinnov.achilles.generated.dsl.EntityWithImplicitFieldParsing_Update;
import info.archinnov.achilles.generated.meta.entity.EntityWithImplicitFieldParsing_AchillesMeta;
import info.archinnov.achilles.internals.dsl.crud.DeleteByPartitionWithOptions;
import info.archinnov.achilles.internals.dsl.crud.DeleteWithOptions;
import info.archinnov.achilles.internals.dsl.crud.FindWithOptions;
import info.archinnov.achilles.internals.dsl.crud.InsertWithOptions;
import info.archinnov.achilles.internals.dsl.crud.UpdateWithOptions;
import info.archinnov.achilles.internals.dsl.raw.NativeQuery;
import info.archinnov.achilles.internals.dsl.raw.TypedQuery;
import info.archinnov.achilles.internals.entities.EntityWithImplicitFieldParsing;
import info.archinnov.achilles.internals.options.CassandraOptions;
import info.archinnov.achilles.internals.runtime.AbstractManager;
import info.archinnov.achilles.internals.runtime.RuntimeEngine;
import info.archinnov.achilles.type.SchemaNameProvider;
import info.archinnov.achilles.validation.Validator;
import java.lang.Class;
import java.lang.Long;
import java.lang.Object;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.UUID;

public final class EntityWithImplicitFieldParsing_Manager extends AbstractManager {
  public final EntityWithImplicitFieldParsing_AchillesMeta meta;

  public EntityWithImplicitFieldParsing_Manager(final Class entityClass, final EntityWithImplicitFieldParsing_AchillesMeta meta, final RuntimeEngine rte) {
    super(entityClass, meta, rte);
    this.meta = meta;
  }

  /**
   * Provide CRUD operations: 
    
   * 
      
   *    
    • FIND BY ID
      • 
   *    
    • INSERT
      • 
   *    
    • INSERT STATIC
      • 
   *    
    • INSERT IF NOT EXISTS
      • 
   *    
    • DELETE BY ID
      • 
   *    
    • DELETE BY ID IF NOT EXISTS
      • 
   *    
    • DELETE BY PARTITION
      • 
   * 
    
   */
  public final EntityWithImplicitFieldParsing_CRUD crud() {
    return new EntityWithImplicitFieldParsing_CRUD();
  }

  /**
   * Provide DSL methods: 
    
   * 
      
   *    
    • SELECT
      • 
   *    
    • ITERATION ON SELECT
      • 
   *    
    • UPDATE
      • 
   *    
    • DELETE
      • 
   * 
    
   */
  public final EntityWithImplicitFieldParsing_DSL dsl() {
    return new EntityWithImplicitFieldParsing_DSL();
  }

  /**
   * Provide Raw query methods: 
    
   * 
      
   *    
    • Typed Queries (for SELECT only)
      • 
   *    
    • Native Queries (for any kind of statement)
      • 
   * 
    
   */
  public final EntityWithImplicitFieldParsing_RAW_QUERY raw() {
    return new EntityWithImplicitFieldParsing_RAW_QUERY();
  }

  public final class EntityWithImplicitFieldParsing_CRUD {
    private Optional cassandraOptions = Optional.empty();
    ;

    public EntityWithImplicitFieldParsing_Manager.EntityWithImplicitFieldParsing_CRUD withSchemaNameProvider(final SchemaNameProvider schemaNameProvider) {
      Validator.validateNotNull(schemaNameProvider,"The provided schemaNameProvider should not be null");
      this.cassandraOptions = Optional.of(CassandraOptions.withSchemaNameProvider(schemaNameProvider));
      return this;
    }

    /**
     * Find an entity by its complete primary key@param id partition key 'id'@param uuid clustering column 'uuid'@return FindWithOptions */
    public FindWithOptions findById(final Long id, final UUID uuid) {
      List keys = new ArrayList<>();
      List encodedKeys = new ArrayList<>();
      Validator.validateNotNull(id, "Partition key '%s' should not be null", "id");
      keys.add(id);
      encodedKeys.add(EntityWithImplicitFieldParsing_AchillesMeta.id.encodeFromJava(id, cassandraOptions));
      Validator.validateNotNull(uuid, "Partition key '%s' should not be null", "uuid");
      keys.add(uuid);
      encodedKeys.add(EntityWithImplicitFieldParsing_AchillesMeta.uuid.encodeFromJava(uuid, cassandraOptions));
      final Object[] primaryKeyValues = keys.toArray();
      final Object[] encodedPrimaryKeyValues = encodedKeys.toArray();
      return new FindWithOptions(entityClass, meta, rte, primaryKeyValues, encodedPrimaryKeyValues, cassandraOptions);
    }

    /**
     * Delete an entity instance by extracting its primary keyRemark: Achilles will throw an exception if any column being part of the primary key is NULL@param an instance of EntityWithImplicitFieldParsing to be delete@return DeleteWithOptions */
    public DeleteWithOptions delete(final EntityWithImplicitFieldParsing instance) {
      return deleteInternal(instance, cassandraOptions);
    }

    /**
     * Delete an entity using its complete primary key@param id partition key 'id'@param uuid clustering column 'uuid'@return DeleteWithOptions */
    public DeleteWithOptions deleteById(final Long id, final UUID uuid) {
      List keys = new ArrayList<>();
      List encodedKeys = new ArrayList<>();
      Validator.validateNotNull(id, "Partition key '%s' should not be null", "id");
      keys.add(id);
      encodedKeys.add(EntityWithImplicitFieldParsing_AchillesMeta.id.encodeFromJava(id, cassandraOptions));
      Validator.validateNotNull(uuid, "Partition key '%s' should not be null", "uuid");
      keys.add(uuid);
      encodedKeys.add(EntityWithImplicitFieldParsing_AchillesMeta.uuid.encodeFromJava(uuid, cassandraOptions));
      final Object[] partitionKeysValues = keys.toArray();
      final Object[] encodedPartitionKeyValues = encodedKeys.toArray();
      return new DeleteWithOptions(entityClass, meta, rte, partitionKeysValues, encodedPartitionKeyValues, Optional.empty(), cassandraOptions);
    }

    /**
     * Insert this entity
     *
     * @param instance an instance of EntityWithImplicitFieldParsing
     * @return InsertWithOptions */
    public final InsertWithOptions insert(final EntityWithImplicitFieldParsing instance) {
      return insertInternal(instance, false, cassandraOptions);
    }

    /**
     * Update the cassandra table with NOT NULL fields extracted from this entity
     *
     * @param instance an instance of EntityWithImplicitFieldParsing
     * @return InsertWithOptions */
    public final UpdateWithOptions update(final EntityWithImplicitFieldParsing instance) {
      return updateInternal(instance, false, cassandraOptions);
    }

    /**
     * Delete a whole partition using the partition key@param id partition key 'id'@return DeleteByPartitionWithOptions */
    public DeleteByPartitionWithOptions deleteByPartitionKeys(final Long id) {
      List keys = new ArrayList<>();
      List encodedKeys = new ArrayList<>();
      Validator.validateNotNull(id, "Partition key '%s' should not be null", "id");
      keys.add(id);
      encodedKeys.add(EntityWithImplicitFieldParsing_AchillesMeta.id.encodeFromJava(id, cassandraOptions));
      final Object[] partitionKeys = keys.toArray();
      final Object[] encodedPartitionKeys = encodedKeys.toArray();
      return new DeleteByPartitionWithOptions(meta, rte, partitionKeys, encodedPartitionKeys, cassandraOptions);
    }
  }

  public final class EntityWithImplicitFieldParsing_DSL {
    /**
     * Generate a SELECT statement@return EntityWithImplicitFieldParsing_Select */
    public final EntityWithImplicitFieldParsing_Select select() {
      return new EntityWithImplicitFieldParsing_Select(rte, meta);
    }

    /**
     * Generate a DELETE statement@return EntityWithImplicitFieldParsing_Delete */
    public final EntityWithImplicitFieldParsing_Delete delete() {
      return new EntityWithImplicitFieldParsing_Delete(rte, meta);
    }

    /**
     * Generate an UPDATE statement@return EntityWithImplicitFieldParsing_Update */
    public final EntityWithImplicitFieldParsing_Update update() {
      return new EntityWithImplicitFieldParsing_Update(rte, meta);
    }
  }

  public final class EntityWithImplicitFieldParsing_RAW_QUERY {
    /**
     * Execute the bound statement and map the result back into an instance of EntityWithImplicitFieldParsing 
    
     * Remark: the bound statement should be a SELECT statement@param boundStatement a bound statement@return TypedQuery */
    public final TypedQuery typedQueryForSelect(BoundStatement boundStatement) {
      return typedQueryForSelectInternal(boundStatement);
    }

    /**
     * Execute the prepared statement and map the result back into an instance of EntityWithImplicitFieldParsing 
    
     * Remark: the prepared statement should be a SELECT statement@param preparedStatement a prepared statement@return TypedQuery */
    public final TypedQuery typedQueryForSelect(PreparedStatement preparedStatement, Object... encodedBoundValues) {
      return typedQueryForSelectInternal(preparedStatement, encodedBoundValues);
    }

    /**
     * Execute the regular statement and map the result back into an instance of EntityWithImplicitFieldParsing 
    
     * Remark: the regular statement should be a SELECT statement@param regularStatement a regular statement@return TypedQuery */
    public final TypedQuery typedQueryForSelect(RegularStatement regularStatement, Object... encodedBoundValues) {
      return typedQueryForSelectInternal(regularStatement, encodedBoundValues);
    }

    /**
     * Execute the native bound statement@param boundStatement a bound statement@return NativeQuery */
    public final NativeQuery nativeQuery(BoundStatement boundStatement) {
      return nativeQueryInternal(boundStatement);
    }

    /**
     * Execute the native prepared statement@param preparedStatement a prepared statement@return NativeQuery */
    public final NativeQuery nativeQuery(PreparedStatement preparedStatement, Object... encodedBoundValues) {
      return nativeQueryInternal(preparedStatement, encodedBoundValues);
    }

    /**
     * Execute the native regular statement@param regularStatement a regular statement@return NativeQuery */
    public final NativeQuery nativeQuery(RegularStatement regularStatement, Object... encodedBoundValues) {
      return nativeQueryInternal(regularStatement, encodedBoundValues);
    }
  }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy