### Home Classes Methods

### In Files

- lib/sequel/adapters/jdbc.rb
- lib/sequel/adapters/mysql.rb
- lib/sequel/adapters/oracle.rb
- lib/sequel/adapters/postgres.rb
- lib/sequel/adapters/utils/stored_procedures.rb
- lib/sequel/dataset.rb
- lib/sequel/dataset/actions.rb
- lib/sequel/dataset/features.rb
- lib/sequel/dataset/graph.rb
- lib/sequel/dataset/misc.rb
- lib/sequel/dataset/prepared_statements.rb
- lib/sequel/dataset/query.rb
- lib/sequel/dataset/sql.rb
- lib/sequel/dataset/mutation.rb
- lib/sequel/extensions/pagination.rb
- lib/sequel/extensions/pretty_table.rb
- lib/sequel/extensions/query.rb
- lib/sequel/extensions/to_dot.rb
- lib/sequel/extensions/columns_introspection.rb

### Parent

Sequel::Dataset

### Namespace

- MODULE Sequel::Dataset::ArgumentMapper
- MODULE Sequel::Dataset::BindArgumentMethods
- MODULE Sequel::Dataset::Pagination
- MODULE Sequel::Dataset::PreparedStatementMethods
- MODULE Sequel::Dataset::QueryBlockCopy
- MODULE Sequel::Dataset::StoredProcedureMethods
- MODULE Sequel::Dataset::StoredProcedures
- MODULE Sequel::Dataset::UnnumberedArgumentMapper
- CLASS Sequel::Dataset::TYPE_TRANSLATOR

### Methods

- ::clause_methods
- ::def_append_methods
- ::def_mutation_method
- ::introspect_all_columns
- ::new
- #<<
- #==
- #[]
- #[]=
- #_filter
- #_filter_or_exclude
- #_import
- #_insert_sql
- #_select_map
- #_select_map_multiple
- #_select_map_single
- #_truncate_sql
- #_update_sql
- #add_graph_aliases
- #affected_rows
- #aggregate_dataset
- #alias_alias_symbol
- #alias_symbol
- #aliased_expression_sql_append
- #all
- #and
- #argument_list_append
- #array_sql_append
- #as_sql_append
- #avg
- #bind
- #boolean_constant_sql_append
- #call
- #case_expression_sql_append
- #cast_sql_append
- #check_modification_allowed!
- #clause_sql
- #clone
- #column_all_sql_append
- #column_list_append
- #columns
- #columns!
- #columns_without_introspection
- #complex_expression_arg_pairs
- #complex_expression_sql_append
- #compound_clone
- #compound_dataset_sql_append
- #compound_from_self
- #constant_sql_append
- #convert_type_proc
- #convert_type_timestamp
- #count
- #cursor_fetch_rows
- #dataset_alias
- #def_mutation_method
- #default_server
- #default_server_opts
- #default_timestamp_format
- #delete
- #delete_clause_methods
- #delete_delete_sql
- #delete_from_sql
- #delete_order_sql
- #delete_returning_sql
- #delete_sql
- #delete_where_sql
- #delete_with_sql
- #distinct
- #each
- #each_page
- #each_server
- #empty?
- #empty_array_value
- #eql?
- #except
- #exclude
- #exclude_having
- #exclude_where
- #execute
- #execute_ddl
- #execute_dui
- #execute_insert
- #exists
- #expression_list_append
- #fetch_rows
- #fetch_rows_set_cols
- #filter
- #filter_expr
- #first
- #first_source
- #first_source_alias
- #first_source_table
- #for_update
- #format_timestamp
- #format_timestamp_offset
- #format_timestamp_usec
- #from
- #from_self
- #function_sql_append
- #get
- #graph
- #graph_alias_columns
- #graph_each
- #grep
- #group
- #group_and_count
- #group_by
- #group_cube
- #group_rollup
- #hash
- #hash_key_symbol
- #having
- #hoist_cte
- #hoist_cte?
- #identifier_append
- #identifier_input_method
- #identifier_output_method
- #import
- #input_identifier
- #insert
- #insert_clause_methods
- #insert_columns_sql
- #insert_insert_sql
- #insert_into_sql
- #insert_multiple
- #insert_returning_sql
- #insert_sql
- #insert_supports_empty_values?
- #insert_values_sql
- #insert_with_sql
- #inspect
- #intersect
- #interval
- #invert
- #invert_order
- #join
- #join_clause_sql_append
- #join_on_clause_sql_append
- #join_table
- #join_type_sql
- #join_using_clause_sql_append
- #joined_dataset?
- #last
- #limit
- #literal_append
- #literal_array_append
- #literal_big_decimal
- #literal_blob_append
- #literal_dataset_append
- #literal_date
- #literal_datetime
- #literal_expression_append
- #literal_false
- #literal_float
- #literal_hash_append
- #literal_integer
- #literal_nil
- #literal_other_append
- #literal_sqltime
- #literal_string_append
- #literal_symbol_append
- #literal_time
- #literal_true
- #lock_style
- #map
- #max
- #min
- #multi_insert
- #multi_insert_sql
- #mutation_method
- #naked
- #naked!
- #negative_boolean_constant_sql_append
- #offset_returns_row_number_column?
- #options_overlap
- #or
- #order
- #order_append
- #order_by
- #order_more
- #order_prepend
- #ordered_expression_sql_append
- #output_identifier
- #paginate
- #placeholder_literal_string_sql_append
- #post_load
- #prepare
- #prepare_extend_sproc
- #prepared_arg_placeholder
- #print
- #process_result_set
- #process_result_set_convert
- #process_result_set_no_convert
- #provides_accurate_rows_matched?
- #qualified_column_name
- #qualified_expression
- #qualified_identifier_sql_append
- #qualify
- #qualify_to
- #qualify_to_first_source
- #query
- #quote_identifier_append
- #quote_identifiers?
- #quote_schema_table_append
- #quoted_identifier_append
- #range
- #recursive_cte_requires_column_aliases?
- #replace
- #requires_placeholder_type_specifiers?
- #requires_sql_standard_datetimes?
- #returning
- #returning_fetch_rows
- #reverse
- #reverse_order
- #row_number_column
- #schema_and_table
- #select
- #select_all
- #select_append
- #select_clause_methods
- #select_columns_sql
- #select_compounds_sql
- #select_distinct_sql
- #select_from_sql
- #select_group
- #select_group_sql
- #select_hash
- #select_having_sql
- #select_join_sql
- #select_limit_sql
- #select_lock_sql
- #select_map
- #select_more
- #select_order_map
- #select_order_sql
- #select_select_sql
- #select_sql
- #select_where_sql
- #select_with_sql
- #select_with_sql_base
- #server
- #set
- #set_defaults
- #set_graph_aliases
- #set_overrides
- #simple_select_all?
- #single_record
- #single_value
- #source_list_append
- #split_alias
- #split_multiple_result_sets
- #split_symbol
- #sql
- #static_sql
- #subscript_sql_append
- #subselect_sql_append
- #sum
- #supports_cte?
- #supports_cte_in_subqueries?
- #supports_distinct_on?
- #supports_group_cube?
- #supports_group_rollup?
- #supports_insert_select?
- #supports_intersect_except?
- #supports_intersect_except_all?
- #supports_is_true?
- #supports_join_using?
- #supports_modifying_joins?
- #supports_multiple_column_in?
- #supports_ordered_distinct_on?
- #supports_returning?
- #supports_select_all_and_column?
- #supports_timestamp_timezones?
- #supports_timestamp_usecs?
- #supports_where_true?
- #supports_window_functions?
- #table_ref_append
- #to_csv
- #to_dot
- #to_hash
- #to_prepared_statement
- #truncate
- #truncate_sql
- #unaliased_identifier
- #unbind
- #unfiltered
- #ungraphed
- #ungrouped
- #union
- #unlimited
- #unordered
- #unused_table_alias
- #update
- #update_clause_methods
- #update_order_sql
- #update_returning_sql
- #update_set_sql
- #update_sql
- #update_table_sql
- #update_update_sql
- #update_where_sql
- #update_with_sql
- #use_cursor
- #uses_returning?
- #virtual_row_columns
- #where
- #window_function_sql_append
- #window_sql_append
- #with
- #with_recursive
- #with_sql
- #yield_hash_rows
- #yield_rows

### Included Modules

- StoredProcedures
- Sequel::MySQL::DatasetMethods
- Sequel::MySQL::PreparedStatements::DatasetMethods
- DatasetMethods
- Sequel::Postgres::DatasetMethods
- Metaprogramming
- Enumerable
- SQL::AliasMethods
- SQL::BooleanMethods
- SQL::CastMethods
- SQL::ComplexExpressionMethods
- SQL::InequalityMethods
- SQL::NumericMethods
- SQL::OrderMethods
- SQL::StringMethods
- ColumnsIntrospection

### Files

- CHANGELOG
- MIT-LICENSE
- README.rdoc
- active_record.rdoc
- advanced_associations.rdoc
- association_basics.rdoc
- cheat_sheet.rdoc
- dataset_basics.rdoc
- dataset_filtering.rdoc
- mass_assignment.rdoc
- migration.rdoc
- model_hooks.rdoc
- opening_databases.rdoc
- prepared_statements.rdoc
- querying.rdoc
- reflection.rdoc
- 1.0.txt
- 1.1.txt
- 1.3.txt
- 1.4.0.txt
- 1.5.0.txt
- 2.0.0.txt
- 2.1.0.txt
- 2.10.0.txt
- 2.11.0.txt
- 2.12.0.txt
- 2.2.0.txt
- 2.3.0.txt
- 2.4.0.txt
- 2.5.0.txt
- 2.6.0.txt
- 2.7.0.txt
- 2.8.0.txt
- 2.9.0.txt
- 3.0.0.txt
- 3.1.0.txt
- 3.10.0.txt
- 3.11.0.txt
- 3.12.0.txt
- 3.13.0.txt
- 3.14.0.txt
- 3.15.0.txt
- 3.16.0.txt
- 3.17.0.txt
- 3.18.0.txt
- 3.19.0.txt
- 3.2.0.txt
- 3.20.0.txt
- 3.21.0.txt
- 3.22.0.txt
- 3.23.0.txt
- 3.24.0.txt
- 3.25.0.txt
- 3.26.0.txt
- 3.27.0.txt
- 3.28.0.txt
- 3.29.0.txt
- 3.3.0.txt
- 3.30.0.txt
- 3.31.0.txt
- 3.32.0.txt
- 3.33.0.txt
- 3.4.0.txt
- 3.5.0.txt
- 3.6.0.txt
- 3.7.0.txt
- 3.8.0.txt
- 3.9.0.txt
- schema_modification.rdoc
- sharding.rdoc
- sql.rdoc
- testing.rdoc
- transactions.rdoc
- validations.rdoc
- virtual_rows.rdoc

### Class Index

Quicksearch

- Sequel
- Sequel::ADO
- Sequel::ADO::Database
- Sequel::ADO::Dataset
- Sequel::ADO::MSSQL
- Sequel::ADO::MSSQL::DatabaseMethods
- Sequel::ADO::MSSQL::Dataset
- Sequel::ASTTransformer
- Sequel::Access
- Sequel::Access::DatabaseMethods
- Sequel::Access::DatasetMethods
- Sequel::Adapter
- Sequel::AdapterNotFound
- Sequel::AdapterNotFound
- Sequel::Amalgalite
- Sequel::Amalgalite::Database
- Sequel::Amalgalite::Dataset
- Sequel::Amalgalite::SequelTypeMap
- Sequel::ArbitraryServers
- Sequel::BasicObject
- Sequel::ColumnsIntrospection
- Sequel::ConnectionPool
- Sequel::ConnectionPool::ClassMethods
- Sequel::DB2
- Sequel::DB2::DB2Error
- Sequel::DB2::Database
- Sequel::DB2::DatabaseMethods
- Sequel::DB2::Dataset
- Sequel::DB2::DatasetMethods
- Sequel::DBI
- Sequel::DBI::Database
- Sequel::DBI::Dataset
- Sequel::DataObjects
- Sequel::DataObjects::Database
- Sequel::DataObjects::Dataset
- Sequel::DataObjects::MySQL
- Sequel::DataObjects::MySQL::DatabaseMethods
- Sequel::DataObjects::MySQL::Dataset
- Sequel::DataObjects::Postgres
- Sequel::DataObjects::Postgres::AdapterMethods
- Sequel::DataObjects::Postgres::DatabaseMethods
- Sequel::DataObjects::Postgres::Dataset
- Sequel::DataObjects::SQLite
- Sequel::DataObjects::SQLite::DatabaseMethods
- Sequel::DataObjects::SQLite::Dataset
- Sequel::Database
- Sequel::DatabaseConnectionError
- Sequel::DatabaseDisconnectError
- Sequel::DatabaseError
- Sequel::Dataset
- Sequel::Dataset
- Sequel::Dataset::ArgumentMapper
- Sequel::Dataset::BindArgumentMethods
- Sequel::Dataset::Pagination
- Sequel::Dataset::PreparedStatementMethods
- Sequel::Dataset::QueryBlockCopy
- Sequel::Dataset::StoredProcedureMethods
- Sequel::Dataset::StoredProcedures
- Sequel::Dataset::TYPE_TRANSLATOR
- Sequel::Dataset::UnnumberedArgumentMapper
- Sequel::EmulateOffsetWithRowNumber
- Sequel::Error
- Sequel::Firebird
- Sequel::Firebird::Database
- Sequel::Firebird::DatabaseMethods
- Sequel::Firebird::Dataset
- Sequel::Firebird::DatasetMethods
- Sequel::HookFailed
- Sequel::HookFailed
- Sequel::IBMDB
- Sequel::IBMDB::Connection
- Sequel::IBMDB::Connection::Error
- Sequel::IBMDB::Database
- Sequel::IBMDB::Dataset
- Sequel::IBMDB::Dataset::CallableStatementMethods
- Sequel::IBMDB::Dataset::PreparedStatementMethods
- Sequel::IBMDB::Statement
- Sequel::Inflections
- Sequel::Informix
- Sequel::Informix::Database
- Sequel::Informix::DatabaseMethods
- Sequel::Informix::Dataset
- Sequel::Informix::DatasetMethods
- Sequel::IntegerMigrator
- Sequel::InvalidOperation
- Sequel::InvalidOperation
- Sequel::InvalidValue
- Sequel::InvalidValue
- Sequel::JDBC
- Sequel::JDBC::AS400
- Sequel::JDBC::AS400::DatabaseMethods
- Sequel::JDBC::AS400::Dataset
- Sequel::JDBC::DB2
- Sequel::JDBC::DB2::DatabaseMethods
- Sequel::JDBC::DB2::Dataset
- Sequel::JDBC::Database
- Sequel::JDBC::Derby
- Sequel::JDBC::Derby::DatabaseMethods
- Sequel::JDBC::Derby::Dataset
- Sequel::JDBC::Firebird
- Sequel::JDBC::Firebird::DatabaseMethods
- Sequel::JDBC::Firebird::Dataset
- Sequel::JDBC::H2
- Sequel::JDBC::H2::DatabaseMethods
- Sequel::JDBC::H2::Dataset
- Sequel::JDBC::HSQLDB
- Sequel::JDBC::HSQLDB::DatabaseMethods
- Sequel::JDBC::HSQLDB::Dataset
- Sequel::JDBC::Informix
- Sequel::JDBC::Informix::DatabaseMethods
- Sequel::JDBC::Informix::Dataset
- Sequel::JDBC::JTDS
- Sequel::JDBC::JTDS::DatabaseMethods
- Sequel::JDBC::JTDS::Dataset
- Sequel::JDBC::JavaLang
- Sequel::JDBC::JavaSQL
- Sequel::JDBC::JavaxNaming
- Sequel::JDBC::MSSQL
- Sequel::JDBC::MSSQL::DatabaseMethods
- Sequel::JDBC::MySQL
- Sequel::JDBC::MySQL::DatabaseMethods
- Sequel::JDBC::MySQL::Dataset
- Sequel::JDBC::Oracle
- Sequel::JDBC::Oracle::DatabaseMethods
- Sequel::JDBC::Oracle::Dataset
- Sequel::JDBC::Postgres
- Sequel::JDBC::Postgres::AdapterMethods
- Sequel::JDBC::Postgres::DatabaseMethods
- Sequel::JDBC::Postgres::Dataset
- Sequel::JDBC::SQLServer
- Sequel::JDBC::SQLServer::DatabaseMethods
- Sequel::JDBC::SQLServer::DatabaseMethods::MetadataDatasetMethods
- Sequel::JDBC::SQLServer::Dataset
- Sequel::JDBC::SQLite
- Sequel::JDBC::SQLite::DatabaseMethods
- Sequel::JDBC::SQLite::Dataset
- Sequel::JDBC::Transactions
- Sequel::LiteralString
- Sequel::LooserTypecasting
- Sequel::MSSQL
- Sequel::MSSQL::DatabaseMethods
- Sequel::MSSQL::DatasetMethods
- Sequel::Metaprogramming
- Sequel::Migration
- Sequel::MigrationAlterTableReverser
- Sequel::MigrationDSL
- Sequel::MigrationReverser
- Sequel::Migrator
- Sequel::Migrator::Error
- Sequel::Mock
- Sequel::Mock::Connection
- Sequel::Mock::Database
- Sequel::Mock::Dataset
- Sequel::Model
- Sequel::Model::Associations
- Sequel::Model::Associations::AssociationDatasetMethods
- Sequel::Model::Associations::AssociationReflection
- Sequel::Model::Associations::ClassMethods
- Sequel::Model::Associations::DatasetMethods
- Sequel::Model::Associations::EagerGraphLoader
- Sequel::Model::Associations::InstanceMethods
- Sequel::Model::Associations::ManyToManyAssociationReflection
- Sequel::Model::Associations::ManyToOneAssociationReflection
- Sequel::Model::Associations::OneToManyAssociationReflection
- Sequel::Model::Associations::OneToOneAssociationReflection
- Sequel::Model::ClassMethods
- Sequel::Model::DatasetMethods
- Sequel::Model::Errors
- Sequel::Model::InstanceMethods
- Sequel::MySQL
- Sequel::MySQL::DatabaseMethods
- Sequel::MySQL::DatasetMethods
- Sequel::MySQL::DatasetMethods::CallableStatementMethods
- Sequel::MySQL::DatasetMethods::PreparedStatementMethods
- Sequel::MySQL::DatasetMethods::StoredProcedureMethods
- Sequel::MySQL::PreparedStatements
- Sequel::MySQL::PreparedStatements::DatabaseMethods
- Sequel::Mysql2
- Sequel::Mysql2::Database
- Sequel::Mysql2::Dataset
- Sequel::NamedTimezones
- Sequel::NoExistingObject
- Sequel::NoExistingObject
- Sequel::NotImplemented
- Sequel::ODBC
- Sequel::ODBC::DB2
- Sequel::ODBC::DB2::DatabaseMethods
- Sequel::ODBC::DB2::Dataset
- Sequel::ODBC::Database
- Sequel::ODBC::Dataset
- Sequel::ODBC::MSSQL
- Sequel::ODBC::MSSQL::DatabaseMethods
- Sequel::ODBC::MSSQL::Dataset
- Sequel::OpenBase
- Sequel::OpenBase::Database
- Sequel::OpenBase::Dataset
- Sequel::Oracle
- Sequel::Oracle::Database
- Sequel::Oracle::DatabaseMethods
- Sequel::Oracle::DatasetMethods
- Sequel::Plugins
- Sequel::Plugins::ActiveModel
- Sequel::Plugins::ActiveModel::ClassMethods
- Sequel::Plugins::ActiveModel::InstanceMethods
- Sequel::Plugins::AssociationAutoreloading
- Sequel::Plugins::AssociationAutoreloading::ClassMethods
- Sequel::Plugins::AssociationDependencies
- Sequel::Plugins::AssociationDependencies::ClassMethods
- Sequel::Plugins::AssociationDependencies::InstanceMethods
- Sequel::Plugins::AssociationPks
- Sequel::Plugins::AssociationPks::ClassMethods
- Sequel::Plugins::AssociationPks::InstanceMethods
- Sequel::Plugins::AssociationProxies
- Sequel::Plugins::AssociationProxies::AssociationProxy
- Sequel::Plugins::AssociationProxies::ClassMethods
- Sequel::Plugins::BooleanReaders
- Sequel::Plugins::BooleanReaders::ClassMethods
- Sequel::Plugins::Caching
- Sequel::Plugins::Caching::ClassMethods
- Sequel::Plugins::Caching::InstanceMethods
- Sequel::Plugins::ClassTableInheritance
- Sequel::Plugins::ClassTableInheritance::ClassMethods
- Sequel::Plugins::ClassTableInheritance::InstanceMethods
- Sequel::Plugins::Composition
- Sequel::Plugins::Composition::ClassMethods
- Sequel::Plugins::Composition::InstanceMethods
- Sequel::Plugins::DatasetAssociations
- Sequel::Plugins::DatasetAssociations::ClassMethods
- Sequel::Plugins::DatasetAssociations::DatasetMethods
- Sequel::Plugins::DefaultsSetter
- Sequel::Plugins::DefaultsSetter::ClassMethods
- Sequel::Plugins::DefaultsSetter::InstanceMethods
- Sequel::Plugins::ForceEncoding
- Sequel::Plugins::ForceEncoding::ClassMethods
- Sequel::Plugins::ForceEncoding::InstanceMethods
- Sequel::Plugins::HookClassMethods
- Sequel::Plugins::HookClassMethods::ClassMethods
- Sequel::Plugins::HookClassMethods::InstanceMethods
- Sequel::Plugins::IdentityMap
- Sequel::Plugins::IdentityMap::ClassMethods
- Sequel::Plugins::IdentityMap::InstanceMethods
- Sequel::Plugins::InstanceFilters
- Sequel::Plugins::InstanceFilters::InstanceMethods
- Sequel::Plugins::InstanceHooks
- Sequel::Plugins::InstanceHooks::InstanceMethods
- Sequel::Plugins::JsonSerializer
- Sequel::Plugins::JsonSerializer::ClassMethods
- Sequel::Plugins::JsonSerializer::DatasetMethods
- Sequel::Plugins::JsonSerializer::InstanceMethods
- Sequel::Plugins::JsonSerializer::Literal
- Sequel::Plugins::LazyAttributes
- Sequel::Plugins::LazyAttributes::ClassMethods
- Sequel::Plugins::LazyAttributes::InstanceMethods
- Sequel::Plugins::List
- Sequel::Plugins::List::ClassMethods
- Sequel::Plugins::List::InstanceMethods
- Sequel::Plugins::ManyThroughMany
- Sequel::Plugins::ManyThroughMany::ClassMethods
- Sequel::Plugins::ManyThroughMany::DatasetMethods
- Sequel::Plugins::ManyThroughMany::ManyThroughManyAssociationReflection
- Sequel::Plugins::NestedAttributes
- Sequel::Plugins::NestedAttributes::ClassMethods
- Sequel::Plugins::NestedAttributes::InstanceMethods
- Sequel::Plugins::OptimisticLocking
- Sequel::Plugins::OptimisticLocking::ClassMethods
- Sequel::Plugins::OptimisticLocking::InstanceMethods
- Sequel::Plugins::PreparedStatements
- Sequel::Plugins::PreparedStatements::ClassMethods
- Sequel::Plugins::PreparedStatements::InstanceMethods
- Sequel::Plugins::PreparedStatementsAssociations
- Sequel::Plugins::PreparedStatementsAssociations::ClassMethods
- Sequel::Plugins::PreparedStatementsAssociations::InstanceMethods
- Sequel::Plugins::PreparedStatementsSafe
- Sequel::Plugins::PreparedStatementsSafe::ClassMethods
- Sequel::Plugins::PreparedStatementsSafe::InstanceMethods
- Sequel::Plugins::PreparedStatementsWithPk
- Sequel::Plugins::PreparedStatementsWithPk::ClassMethods
- Sequel::Plugins::PreparedStatementsWithPk::DatasetMethods
- Sequel::Plugins::RcteTree
- Sequel::Plugins::Schema
- Sequel::Plugins::Schema::ClassMethods
- Sequel::Plugins::Serialization
- Sequel::Plugins::Serialization::ClassMethods
- Sequel::Plugins::Serialization::InstanceMethods
- Sequel::Plugins::SerializationModificationDetection
- Sequel::Plugins::SerializationModificationDetection::InstanceMethods
- Sequel::Plugins::Sharding
- Sequel::Plugins::Sharding::ClassMethods
- Sequel::Plugins::Sharding::DatasetMethods
- Sequel::Plugins::Sharding::InstanceMethods
- Sequel::Plugins::SingleTableInheritance
- Sequel::Plugins::SingleTableInheritance::ClassMethods
- Sequel::Plugins::SingleTableInheritance::InstanceMethods
- Sequel::Plugins::SkipCreateRefresh
- Sequel::Plugins::SkipCreateRefresh::InstanceMethods
- Sequel::Plugins::StringStripper
- Sequel::Plugins::StringStripper::InstanceMethods
- Sequel::Plugins::Subclasses
- Sequel::Plugins::Subclasses::ClassMethods
- Sequel::Plugins::TacticalEagerLoading
- Sequel::Plugins::TacticalEagerLoading::DatasetMethods
- Sequel::Plugins::TacticalEagerLoading::InstanceMethods
- Sequel::Plugins::Timestamps
- Sequel::Plugins::Timestamps::ClassMethods
- Sequel::Plugins::Timestamps::InstanceMethods
- Sequel::Plugins::Touch
- Sequel::Plugins::Touch::ClassMethods
- Sequel::Plugins::Touch::InstanceMethods
- Sequel::Plugins::Tree
- Sequel::Plugins::Tree::ClassMethods
- Sequel::Plugins::Tree::InstanceMethods
- Sequel::Plugins::Tree::SingleRoot
- Sequel::Plugins::Tree::SingleRoot::ClassMethods
- Sequel::Plugins::Tree::SingleRoot::InstanceMethods
- Sequel::Plugins::Tree::TreeMultipleRootError
- Sequel::Plugins::TypecastOnLoad
- Sequel::Plugins::TypecastOnLoad::ClassMethods
- Sequel::Plugins::TypecastOnLoad::InstanceMethods
- Sequel::Plugins::UpdatePrimaryKey
- Sequel::Plugins::UpdatePrimaryKey::ClassMethods
- Sequel::Plugins::UpdatePrimaryKey::InstanceMethods
- Sequel::Plugins::ValidationClassMethods
- Sequel::Plugins::ValidationClassMethods::ClassMethods
- Sequel::Plugins::ValidationClassMethods::ClassMethods::Generator
- Sequel::Plugins::ValidationClassMethods::InstanceMethods
- Sequel::Plugins::ValidationHelpers
- Sequel::Plugins::ValidationHelpers::InstanceMethods
- Sequel::Plugins::XmlSerializer
- Sequel::Plugins::XmlSerializer::ClassMethods
- Sequel::Plugins::XmlSerializer::DatasetMethods
- Sequel::Plugins::XmlSerializer::InstanceMethods
- Sequel::PoolTimeout
- Sequel::PoolTimeout
- Sequel::Postgres
- Sequel::Postgres::AdapterMethods
- Sequel::Postgres::DatabaseMethods
- Sequel::Postgres::DatasetMethods
- Sequel::Postgres::DatasetMethods::PreparedStatementMethods
- Sequel::PrettyTable
- Sequel::Progress
- Sequel::Progress::DatabaseMethods
- Sequel::Progress::DatasetMethods
- Sequel::Qualifier
- Sequel::Rollback
- Sequel::Rollback
- Sequel::SQL
- Sequel::SQL::AliasMethods
- Sequel::SQL::AliasedExpression
- Sequel::SQL::BitwiseMethods
- Sequel::SQL::Blob
- Sequel::SQL::BooleanConstant
- Sequel::SQL::BooleanExpression
- Sequel::SQL::BooleanMethods
- Sequel::SQL::CaseExpression
- Sequel::SQL::Cast
- Sequel::SQL::CastMethods
- Sequel::SQL::ColumnAll
- Sequel::SQL::ComplexExpression
- Sequel::SQL::ComplexExpressionMethods
- Sequel::SQL::Constant
- Sequel::SQL::Constants
- Sequel::SQL::Expression
- Sequel::SQL::Function
- Sequel::SQL::GenericComplexExpression
- Sequel::SQL::GenericExpression
- Sequel::SQL::Identifier
- Sequel::SQL::IdentifierMethods
- Sequel::SQL::InequalityMethods
- Sequel::SQL::JoinClause
- Sequel::SQL::JoinOnClause
- Sequel::SQL::JoinUsingClause
- Sequel::SQL::NegativeBooleanConstant
- Sequel::SQL::NoBooleanInputMethods
- Sequel::SQL::NumericExpression
- Sequel::SQL::NumericMethods
- Sequel::SQL::OrderMethods
- Sequel::SQL::OrderedExpression
- Sequel::SQL::PlaceholderLiteralString
- Sequel::SQL::QualifiedIdentifier
- Sequel::SQL::QualifyingMethods
- Sequel::SQL::StringConcatenationMethods
- Sequel::SQL::StringExpression
- Sequel::SQL::StringMethods
- Sequel::SQL::Subscript
- Sequel::SQL::SubscriptMethods
- Sequel::SQL::ValueList
- Sequel::SQL::ValueList
- Sequel::SQL::VirtualRow
- Sequel::SQL::Window
- Sequel::SQL::WindowFunction
- Sequel::SQLTime
- Sequel::SQLite
- Sequel::SQLite::DatabaseMethods
- Sequel::SQLite::DatasetMethods
- Sequel::Schema
- Sequel::Schema::AlterTableGenerator
- Sequel::Schema::Generator
- Sequel::ServerBlock
- Sequel::ShardedSingleConnectionPool
- Sequel::ShardedThreadedConnectionPool
- Sequel::SimpleMigration
- Sequel::SingleConnectionPool
- Sequel::Swift
- Sequel::Swift::Database
- Sequel::Swift::Dataset
- Sequel::Swift::MySQL
- Sequel::Swift::MySQL::DatabaseMethods
- Sequel::Swift::MySQL::Dataset
- Sequel::Swift::Postgres
- Sequel::Swift::Postgres::AdapterMethods
- Sequel::Swift::Postgres::DatabaseMethods
- Sequel::Swift::Postgres::Dataset
- Sequel::Swift::SQLite
- Sequel::Swift::SQLite::DatabaseMethods
- Sequel::Swift::SQLite::Dataset
- Sequel::ThreadLocalTimezones
- Sequel::ThreadedConnectionPool
- Sequel::ThreadedServerBlock
- Sequel::TimestampMigrator
- Sequel::Timezones
- Sequel::TinyTDS
- Sequel::TinyTDS::Database
- Sequel::TinyTDS::Dataset
- Sequel::TinyTDS::Dataset::ArgumentMapper
- Sequel::TinyTDS::Dataset::PreparedStatementMethods
- Sequel::ToDot
- Sequel::UnbindDuplicate
- Sequel::Unbinder
- Sequel::UndefinedAssociation
- Sequel::UnthreadedServerBlock
- Sequel::ValidationFailed
- Dataset
- Dataset::ArgumentMapper
- Dataset::BindArgumentMethods
- Dataset::PreparedStatementMethods
- String
- String::Inflections
- Array
- FalseClass
- Hash
- NilClass
- Numeric
- Object
- PGconn
- PGresult
- Proc
- Symbol
- TrueClass

No matching classes.

# Sequel::Dataset

Dataset class for MySQL datasets accessed via the native driver.

Dataset class for PostgreSQL datasets that use the pg, postgres, or postgres-pr driver.

A dataset represents an SQL query, or more generally, an abstract set of rows in the database. Datasets can be used to create, retrieve, update and delete records.

Query results are always retrieved on demand, so a dataset can be kept around and reused indefinitely (datasets never cache results):

      my_posts = DB[:posts].filter(:author => 'david') # no records are retrieved
      my_posts.all # records are retrieved
      my_posts.all # records are retrieved again

Most dataset methods return modified copies of the dataset (functional style), so you can reuse different datasets to access data:

      posts = DB[:posts]
      davids_posts = posts.filter(:author => 'david')
      old_posts = posts.filter('stamp < ?', Date.today - 7)
      davids_old_posts = davids_posts.filter('stamp < ?', Date.today - 7)

Datasets are Enumerable objects, so they can be manipulated using any of the Enumerable methods, such as map, inject, etc.

For more information, see the "Dataset Basics" guide.

### Constants

DatasetClass
JAVA_SQL_TIMESTAMP

  Cache Java class constants to speed up lookups

JAVA_SQL_TIME
JAVA_SQL_DATE
JAVA_SQL_BLOB
JAVA_SQL_CLOB
JAVA_BUFFERED_READER
JAVA_BIG_DECIMAL
JAVA_BYTE_ARRAY
TYPE_TRANSLATOR_INSTANCE
DECIMAL_METHOD

  Cache type translator methods so that duplicate Method objects are not created.

TIME_METHOD
DATE_METHOD
BUFFERED_READER_METHOD
BYTE_ARRAY_METHOD
BLOB_METHOD
CLOB_METHOD
DatasetClass
AFFECTED_ROWS_RE

  Regular expression used for getting accurate number of rows matched by an update statement.

DatasetClass
PREPARED_ARG_PLACEHOLDER
DatasetClass
PREPARED_ARG_PLACEHOLDER
ACTION_METHODS

  Action methods defined by Sequel that execute code on the database.

NOTIMPL_MSG
ARRAY_ACCESS_ERROR_MSG
ARG_BLOCK_ERROR_MSG
IMPORT_ERROR_MSG
PREPARED_ARG_PLACEHOLDER
COLUMN_CHANGE_OPTS

  The dataset options that require the removal of cached columns if changed.

NON_SQL_OPTIONS

  Which options don’t affect the SQL generation. Used by simple_select_all? to determine if this is a simple SELECT * FROM table.

CONDITIONED_JOIN_TYPES

  These symbols have _join methods created (e.g. inner_join) that call join_table with the symbol, passing along the arguments and block from the method call.

UNCONDITIONED_JOIN_TYPES

  These symbols have _join methods created (e.g. natural_join) that call join_table with the symbol. They only accept a single table argument which is passed to join_table, and they raise an error if called with a block.

JOIN_METHODS

  All methods that return modified datasets with a joined table added.

QUERY_METHODS

  Methods that return modified datasets

ALL
AND_SEPARATOR
APOS
APOS_RE
ARRAY_EMPTY
AS
ASC
BACKSLASH_RE
BOOL_FALSE
BOOL_TRUE
BRACKET_CLOSE
BRACKET_OPEN
CASE_ELSE
CASE_END
CASE_OPEN
CASE_THEN
CASE_WHEN
CAST_OPEN
COLUMN_ALL
COLUMN_REF_RE1
COLUMN_REF_RE2
COLUMN_REF_RE3
COMMA
COMMA_SEPARATOR
CONDITION_FALSE
CONDITION_TRUE
COUNT_FROM_SELF_OPTS
COUNT_OF_ALL_AS_COUNT
DATASET_ALIAS_BASE_NAME
DEFAULT_VALUES
DELETE
DELETE_CLAUSE_METHODS
DESC
DISTINCT
DOT
DOUBLE_APOS
DOUBLE_QUOTE
EQUAL
EXTRACT
FOR_UPDATE
FORMAT_DATE
FORMAT_DATE_STANDARD
FORMAT_OFFSET
FORMAT_TIMESTAMP_RE
FORMAT_TIMESTAMP_USEC
FORMAT_USEC
FRAME_ALL
FRAME_ROWS
FROM
FUNCTION_EMPTY
GROUP_BY
HAVING
INSERT
INSERT_CLAUSE_METHODS
INTO
IS_LITERALS
IS_OPERATORS
LIMIT
N_ARITY_OPERATORS
NOT_SPACE
NULL
NULLS_FIRST
NULLS_LAST
OFFSET
ON
ON_PAREN
ORDER_BY
ORDER_BY_NS
OVER
PAREN_CLOSE
PAREN_OPEN
PAREN_SPACE_OPEN
PARTITION_BY
QUAD_BACKSLASH
QUALIFY_KEYS
QUESTION_MARK
QUESTION_MARK_RE
QUOTE
QUOTE_RE
RETURNING
SELECT
SELECT_CLAUSE_METHODS
SET
SPACE
SQL_WITH
TILDE
TIMESTAMP_FORMAT
STANDARD_TIMESTAMP_FORMAT
TWO_ARITY_OPERATORS
UNDERSCORE
UPDATE
UPDATE_CLAUSE_METHODS
USING
VALUES
WHERE
WILDCARD
PUBLIC_APPEND_METHODS
PRIVATE_APPEND_METHODS
MUTATION_METHODS

  All methods that should have a ! method added that modifies the receiver.

### Attributes

convert_types[RW]

Whether to convert some Java types to ruby types when retrieving rows. Uses the database’s setting by default, can be set to false to roughly double performance when fetching rows.

db[RW]

The database related to this dataset. This is the Database instance that will execute all of this dataset’s queries.

opts[RW]

The hash of options for this dataset, keys are symbols.

identifier_input_method[W]

Set the method to call on identifiers going into the database for this dataset

identifier_output_method[W]

Set the method to call on identifiers coming the database for this dataset

quote_identifiers[W]

Whether to quote identifiers for this dataset

row_proc[RW]

The row_proc for this database, should be any object that responds to `call` with a single hash argument and returns the object you want # to return.

### Public Class Methods

clause_methods(type, clauses) click to toggle source

Given a type (e.g. select) and an array of clauses, return an array of methods to call to build the SQL string.

         # File lib/sequel/dataset/sql.rb, line 181
    181:     def self.clause_methods(type, clauses)
    182:       clauses.map{|clause| :"#{type}_#{clause}_sql"}.freeze
    183:     end

def_append_methods(meths) click to toggle source

         # File lib/sequel/dataset/sql.rb, line 325
    325:     def self.def_append_methods(meths)
    326:       meths.each do |meth|
    327:         class_eval(          def #{meth}(*args, &block)            s = ''            #{meth}_append(s, *args, &block)            s          end, __FILE__, __LINE__ + 1)
    328:       end
    329:     end

def_mutation_method(*meths) click to toggle source

Setup mutation (e.g. filter!) methods. These operate the same as the non-! methods, but replace the options of the current dataset with the options of the resulting dataset.

        # File lib/sequel/dataset/mutation.rb, line 14
    14:     def self.def_mutation_method(*meths)
    15:       meths.each do |meth|
    16:         class_eval("def #{meth}!(*args, &block); mutation_method(:#{meth}, *args, &block) end", __FILE__, __LINE__)
    17:       end
    18:     end

introspect_all_columns() click to toggle source

Enable column introspection for every dataset.

        # File lib/sequel/extensions/columns_introspection.rb, line 56
    56:     def self.introspect_all_columns
    57:       include ColumnsIntrospection
    58:       remove_method(:columns) if instance_methods(false).map{|x| x.to_s}.include?('columns')
    59:     end

new(db, opts = nil) click to toggle source

Constructs a new Dataset instance with an associated database and options. Datasets are usually constructed by invoking the Database#[] method:

      DB[:posts]

Sequel::Dataset is an abstract class that is not useful by itself. Each database adapter provides a subclass of Sequel::Dataset, and has the Database#dataset method return an instance of that subclass.

        # File lib/sequel/dataset/misc.rb, line 28
    28:     def initialize(db, opts = nil)
    29:       @db = db
    30:       @opts = opts || {}
    31:     end

### Public Instance Methods

<<(arg) click to toggle source

Inserts the given argument into the database. Returns self so it can be used safely when chaining:

      DB[:items] << {:id=>0, :name=>'Zero'} << DB[:old_items].select(:id, name)

        # File lib/sequel/dataset/actions.rb, line 22
    22:     def <<(arg)
    23:       insert(arg)
    24:       self
    25:     end

==(o) click to toggle source

Define a hash value such that datasets with the same DB, opts, and SQL will be consider equal.

        # File lib/sequel/dataset/misc.rb, line 35
    35:     def ==(o)
    36:       o.is_a?(self.class) && db == o.db  && opts == o.opts && sql == o.sql
    37:     end

[](*conditions) click to toggle source

Returns the first record matching the conditions. Examples:

      DB[:table][:id=>1] # SELECT * FROM table WHERE (id = 1) LIMIT 1
      # => {:id=1}

        # File lib/sequel/dataset/actions.rb, line 31
    31:     def [](*conditions)
    32:       raise(Error, ARRAY_ACCESS_ERROR_MSG) if (conditions.length == 1 and conditions.first.is_a?(Integer)) or conditions.length == 0
    33:       first(*conditions)
    34:     end

[]=(conditions, values) click to toggle source

Update all records matching the conditions with the values specified. Returns the number of rows affected.

      DB[:table][:id=>1] = {:id=>2} # UPDATE table SET id = 2 WHERE id = 1
      # => 1 # number of rows affected

        # File lib/sequel/dataset/actions.rb, line 41
    41:     def []=(conditions, values)
    42:       filter(conditions).update(values)
    43:     end

add_graph_aliases(graph_aliases) click to toggle source

Adds the given graph aliases to the list of graph aliases to use, unlike `set_graph_aliases`, which replaces the list (the equivalent of `select_more` when graphing). See `set_graph_aliases`.

      DB[:table].add_graph_aliases(:some_alias=>[:table, :column])
      # SELECT ..., table.column AS some_alias
      # => {:table=>{:column=>some_alias_value, ...}, ...}

        # File lib/sequel/dataset/graph.rb, line 17
    17:     def add_graph_aliases(graph_aliases)
    18:       columns, graph_aliases = graph_alias_columns(graph_aliases)
    19:       ds = select_more(*columns)
    20:       ds.opts[:graph_aliases] = (ds.opts[:graph_aliases] || (ds.opts[:graph][:column_aliases] rescue {}) || {}).merge(graph_aliases)
    21:       ds
    22:     end

aliased_expression_sql_append(sql, ae) click to toggle source

SQL fragment for AliasedExpression

         # File lib/sequel/dataset/sql.rb, line 340
    340:     def aliased_expression_sql_append(sql, ae)
    341:       literal_append(sql, ae.expression)
    342:       as_sql_append(sql, ae.aliaz)
    343:     end

all(&block) click to toggle source

Returns an array with all records in the dataset. If a block is given, the array is iterated over after all items have been loaded.

      DB[:table].all # SELECT * FROM table
      # => [{:id=>1, ...}, {:id=>2, ...}, ...]

      # Iterate over all rows in the table
      DB[:table].all{|row| p row}

        # File lib/sequel/dataset/actions.rb, line 53
    53:     def all(&block)
    54:       a = []
    55:       each{|r| a << r}
    56:       post_load(a)
    57:       a.each(&block) if block
    58:       a
    59:     end

and(*cond, &block) click to toggle source

Adds an further filter to an existing filter using AND. If no filter exists an error is raised. This method is identical to # except it expects an existing filter.

      DB[:table].filter(:a).and(:b) # SELECT * FROM table WHERE a AND b

        # File lib/sequel/dataset/query.rb, line 45
    45:     def and(*cond, &block)
    46:       raise(InvalidOperation, "No existing filter found.") unless @opts[:having] || @opts[:where]
    47:       filter(*cond, &block)
    48:     end

array_sql_append(sql, a) click to toggle source

SQL fragment for Array

         # File lib/sequel/dataset/sql.rb, line 346
    346:     def array_sql_append(sql, a)
    347:       if a.empty?
    348:         sql << ARRAY_EMPTY
    349:       else
    350:         sql << PAREN_OPEN
    351:         expression_list_append(sql, a)
    352:         sql << PAREN_CLOSE
    353:       end
    354:     end

avg(column) click to toggle source

Returns the average value for the given column.

      DB[:table].avg(:number) # SELECT avg(number) FROM table LIMIT 1
      # => 3

        # File lib/sequel/dataset/actions.rb, line 65
    65:     def avg(column)
    66:       aggregate_dataset.get{avg(column)}
    67:     end

bind(bind_vars={}) click to toggle source

Set the bind variables to use for the call. If bind variables have already been set for this dataset, they are updated with the contents of bind_vars.

      DB[:table].filter(:id=>:$id).bind(:id=>1).call(:first)
      # SELECT * FROM table WHERE id = ? LIMIT 1 -- (1)
      # => {:id=>1}

         # File lib/sequel/dataset/prepared_statements.rb, line 211
    211:     def bind(bind_vars={})
    212:       clone(:bind_vars=>@opts[:bind_vars] ? @opts[:bind_vars].merge(bind_vars) : bind_vars)
    213:     end

boolean_constant_sql_append(sql, constant) click to toggle source

SQL fragment for BooleanConstants

         # File lib/sequel/dataset/sql.rb, line 357
    357:     def boolean_constant_sql_append(sql, constant)
    358:       if (constant == true || constant == false) && !supports_where_true?
    359:         sql << (constant == true ? CONDITION_TRUE : CONDITION_FALSE)
    360:       else
    361:         literal_append(sql, constant)
    362:       end
    363:     end

call(type, bind_variables={}, *values, &block) click to toggle source

For the given type (:select, :first, :insert, :insert_select, :update, or :delete), run the sql with the bind variables specified in the hash. `values` is a hash passed to insert or update (if one of those types is used), which may contain placeholders.

      DB[:table].filter(:id=>:$id).call(:first, :id=>1)
      # SELECT * FROM table WHERE id = ? LIMIT 1 -- (1)
      # => {:id=>1}

         # File lib/sequel/dataset/prepared_statements.rb, line 222
    222:     def call(type, bind_variables={}, *values, &block)
    223:       prepare(type, nil, *values).call(bind_variables, &block)
    224:     end

call(type, bind_vars={}, *values, &block) click to toggle source

Execute the given type of statement with the hash of values.

         # File lib/sequel/adapters/oracle.rb, line 361
    361:       def call(type, bind_vars={}, *values, &block)
    362:         ps = to_prepared_statement(type, values)
    363:         ps.extend(BindArgumentMethods)
    364:         ps.call(bind_vars, &block)
    365:       end

call(type, bind_vars={}, *values, &block) click to toggle source

Execute the given type of statement with the hash of values.

         # File lib/sequel/adapters/postgres.rb, line 603
    603:         def call(type, bind_vars={}, *values, &block)
    604:           ps = to_prepared_statement(type, values)
    605:           ps.extend(BindArgumentMethods)
    606:           ps.call(bind_vars, &block)
    607:         end

case_expression_sql_append(sql, ce) click to toggle source

SQL fragment for CaseExpression

         # File lib/sequel/dataset/sql.rb, line 366
    366:     def case_expression_sql_append(sql, ce)
    367:       sql << CASE_OPEN
    368:       if ce.expression?
    369:         sql << SPACE
    370:         literal_append(sql, ce.expression)
    371:       end
    372:       w = CASE_WHEN
    373:       t = CASE_THEN
    374:       ce.conditions.each do |c,r|
    375:         sql << w
    376:         literal_append(sql, c)
    377:         sql << t
    378:         literal_append(sql, r)
    379:       end
    380:       sql << CASE_ELSE
    381:       literal_append(sql, ce.default)
    382:       sql << CASE_END
    383:     end

cast_sql_append(sql, expr, type) click to toggle source

SQL fragment for the SQL CAST expression

         # File lib/sequel/dataset/sql.rb, line 386
    386:     def cast_sql_append(sql, expr, type)
    387:       sql << CAST_OPEN
    388:       literal_append(sql, expr)
    389:       sql << AS << db.cast_type_literal(type).to_s
    390:       sql << PAREN_CLOSE
    391:     end

clone(opts = {}) click to toggle source

Returns a new clone of the dataset with with the given options merged. If the options changed include options in COLUMN_CHANGE_OPTS, the cached columns are deleted. This method should generally not be called directly by user code.

        # File lib/sequel/dataset/query.rb, line 54
    54:     def clone(opts = {})
    55:       c = super()
    56:       c.opts = @opts.merge(opts)
    57:       c.instance_variable_set(:@columns, nil) if opts.keys.any?{|o| COLUMN_CHANGE_OPTS.include?(o)}
    58:       c
    59:     end

column_all_sql_append(sql, ca) click to toggle source

SQL fragment for specifying all columns in a given table

         # File lib/sequel/dataset/sql.rb, line 394
    394:     def column_all_sql_append(sql, ca)
    395:       quote_schema_table_append(sql, ca.table)
    396:       sql << COLUMN_ALL
    397:     end

columns() click to toggle source

Returns the columns in the result set in order as an array of symbols. If the columns are currently cached, returns the cached value. Otherwise, a SELECT query is performed to retrieve a single row in order to get the columns.

If you are looking for all columns for a single table and maybe some information about each column (e.g. database type), see `Database#schema`.

      DB[:table].columns
      # => [:id, :name]

        # File lib/sequel/dataset/actions.rb, line 78
    78:     def columns
    79:       return @columns if @columns
    80:       ds = unfiltered.unordered.clone(:distinct => nil, :limit => 1, :offset=>nil)
    81:       ds.each{break}
    82:       @columns = ds.instance_variable_get(:@columns)
    83:       @columns || []
    84:     end

Also aliased as: columns_without_introspection
columns!() click to toggle source

Ignore any cached column information and perform a query to retrieve a row in order to get the columns.

      DB[:table].columns!
      # => [:id, :name]

        # File lib/sequel/dataset/actions.rb, line 91
    91:     def columns!
    92:       @columns = nil
    93:       columns
    94:     end

columns_without_introspection() click to toggle source
Alias for: columns
complex_expression_sql_append(sql, op, args) click to toggle source

         # File lib/sequel/dataset/sql.rb, line 399
    399:     def complex_expression_sql_append(sql, op, args)
    400:       case op
    401:       when *IS_OPERATORS
    402:         r = args.at(1)
    403:         if r.nil? || supports_is_true?
    404:           raise(InvalidOperation, 'Invalid argument used for IS operator') unless v = IS_LITERALS[r]
    405:           sql << PAREN_OPEN
    406:           literal_append(sql, args.at(0))
    407:           sql << SPACE << op.to_s << SPACE
    408:           sql << v << PAREN_CLOSE
    409:         elsif op == :IS
    410:           complex_expression_sql_append(sql, :"=", args)
    411:         else
    412:           complex_expression_sql_append(sql, :OR, [SQL::BooleanExpression.new(:"!=", *args), SQL::BooleanExpression.new(:IS, args.at(0), nil)])
    413:         end
    414:       when :IN, :"NOT IN"
    415:         cols = args.at(0)
    416:         vals = args.at(1)
    417:         col_array = true if cols.is_a?(Array)
    418:         if vals.is_a?(Array)
    419:           val_array = true
    420:           empty_val_array = vals == []
    421:         end
    422:         if empty_val_array
    423:           literal_append(sql, empty_array_value(op, cols))
    424:         elsif col_array
    425:           if !supports_multiple_column_in?
    426:             if val_array
    427:               expr = SQL::BooleanExpression.new(:OR, *vals.to_a.map{|vs| SQL::BooleanExpression.from_value_pairs(cols.to_a.zip(vs).map{|c, v| [c, v]})})
    428:               literal_append(sql, op == :IN ? expr : ~expr)
    429:             else
    430:               old_vals = vals
    431:               vals = vals.naked if vals.is_a?(Sequel::Dataset)
    432:               vals = vals.to_a
    433:               val_cols = old_vals.columns
    434:               complex_expression_sql_append(sql, op, [cols, vals.map!{|x| x.values_at(*val_cols)}])
    435:             end
    436:           else
    437:             # If the columns and values are both arrays, use array_sql instead of
    438:             # literal so that if values is an array of two element arrays, it
    439:             # will be treated as a value list instead of a condition specifier.
    440:             sql << PAREN_OPEN
    441:             literal_append(sql, cols)
    442:             sql << SPACE << op.to_s << SPACE
    443:             if val_array
    444:               array_sql_append(sql, vals)
    445:             else
    446:               literal_append(sql, vals)
    447:             end
    448:             sql << PAREN_CLOSE
    449:           end
    450:         else
    451:           sql << PAREN_OPEN
    452:           literal_append(sql, cols)
    453:           sql << SPACE << op.to_s << SPACE
    454:           literal_append(sql, vals)
    455:           sql << PAREN_CLOSE
    456:         end
    457:       when *TWO_ARITY_OPERATORS
    458:         sql << PAREN_OPEN
    459:         literal_append(sql, args.at(0))
    460:         sql << SPACE << op.to_s << SPACE
    461:         literal_append(sql, args.at(1))
    462:         sql << PAREN_CLOSE
    463:       when *N_ARITY_OPERATORS
    464:         sql << PAREN_OPEN
    465:         c = false
    466:         op_str = " #{op} "
    467:         args.each do |a|
    468:           sql << op_str if c
    469:           literal_append(sql, a)
    470:           c ||= true
    471:         end
    472:         sql << PAREN_CLOSE
    473:       when :NOT
    474:         sql << NOT_SPACE
    475:         literal_append(sql, args.at(0))
    476:       when :NOOP
    477:         literal_append(sql, args.at(0))
    478:       when :'B~'
    479:         sql << TILDE
    480:         literal_append(sql, args.at(0))
    481:       when :extract
    482:         sql << EXTRACT << args.at(0).to_s << FROM
    483:         literal_append(sql, args.at(1))
    484:         sql << PAREN_CLOSE
    485:       else
    486:         raise(InvalidOperation, "invalid operator #{op}")
    487:       end
    488:     end

constant_sql_append(sql, constant) click to toggle source

SQL fragment for constants

         # File lib/sequel/dataset/sql.rb, line 491
    491:     def constant_sql_append(sql, constant)
    492:       sql << constant.to_s
    493:     end

count() click to toggle source

Returns the number of records in the dataset.

      DB[:table].count # SELECT COUNT(*) AS count FROM table LIMIT 1
      # => 3

         # File lib/sequel/dataset/actions.rb, line 100
    100:     def count
    101:       aggregate_dataset.get{COUNT(:*){}.as(count)}.to_i
    102:     end

def_mutation_method(*meths) click to toggle source

Add a mutation method to this dataset instance.

        # File lib/sequel/dataset/mutation.rb, line 37
    37:     def def_mutation_method(*meths)
    38:       meths.each do |meth|
    39:         instance_eval("def #{meth}!(*args, &block); mutation_method(:#{meth}, *args, &block) end", __FILE__, __LINE__)
    40:       end
    41:     end

delete() click to toggle source

Delete rows matching this dataset

         # File lib/sequel/adapters/mysql.rb, line 277
    277:       def delete
    278:         execute_dui(delete_sql){|c| return c.affected_rows}
    279:       end

delete(&block) click to toggle source

Deletes the records in the dataset. The returned value should be number of records deleted, but that is adapter dependent.

      DB[:table].delete # DELETE * FROM table
      # => 3

         # File lib/sequel/dataset/actions.rb, line 109
    109:     def delete(&block)
    110:       sql = delete_sql
    111:       if uses_returning?(:delete)
    112:         returning_fetch_rows(sql, &block)
    113:       else
    114:         execute_dui(sql)
    115:       end
    116:     end

delete_sql() click to toggle source

Returns a DELETE SQL query string. See `delete`.

      dataset.filter{|o| o.price >= 100}.delete_sql
      # => "DELETE FROM items WHERE (price >= 100)"

        # File lib/sequel/dataset/sql.rb, line 12
    12:     def delete_sql
    13:       return static_sql(opts[:sql]) if opts[:sql]
    14:       check_modification_allowed!
    15:       clause_sql(:delete)
    16:     end

distinct(*args) click to toggle source

Returns a copy of the dataset with the SQL DISTINCT clause. The DISTINCT clause is used to remove duplicate rows from the output. If arguments are provided, uses a DISTINCT ON clause, in which case it will only be distinct on those columns, instead of all returned columns. Raises an error if arguments are given and DISTINCT ON is not supported.

     DB[:items].distinct # SQL: SELECT DISTINCT * FROM items
     DB[:items].order(:id).distinct(:id) # SQL: SELECT DISTINCT ON (id) * FROM items ORDER BY id

        # File lib/sequel/dataset/query.rb, line 70
    70:     def distinct(*args)
    71:       raise(InvalidOperation, "DISTINCT ON not supported") if !args.empty? && !supports_distinct_on?
    72:       clone(:distinct => args)
    73:     end

each(&block) click to toggle source

Iterates over the records in the dataset as they are yielded from the database adapter, and returns self.

      DB[:table].each{|row| p row} # SELECT * FROM table

Note that this method is not safe to use on many adapters if you are running additional queries inside the provided block. If you are running queries inside the block, you should use `all` instead of `each` for the outer queries, or use a separate thread or shard inside `each`:

         # File lib/sequel/dataset/actions.rb, line 127
    127:     def each(&block)
    128:       if @opts[:graph]
    129:         graph_each(&block)
    130:       elsif row_proc = @row_proc
    131:         fetch_rows(select_sql){|r| yield row_proc.call(r)}
    132:       else
    133:         fetch_rows(select_sql, &block)
    134:       end
    135:       self
    136:     end

each_page(page_size) click to toggle source

Yields a paginated dataset for each page and returns the receiver. Does a count to find the total number of records for this dataset.

        # File lib/sequel/extensions/pagination.rb, line 20
    20:     def each_page(page_size)
    21:       raise(Error, "You cannot paginate a dataset that already has a limit") if @opts[:limit]
    22:       record_count = count
    23:       total_pages = (record_count / page_size.to_f).ceil
    24:       (1..total_pages).each{|page_no| yield paginate(page_no, page_size, record_count)}
    25:       self
    26:     end

each_server() click to toggle source

Yield a dataset for each server in the connection pool that is tied to that server. Intended for use in sharded environments where all servers need to be modified with the same data:

      DB[:configs].where(:key=>'setting').each_server{|ds| ds.update(:value=>'new_value')}

        # File lib/sequel/dataset/misc.rb, line 49
    49:     def each_server
    50:       db.servers.each{|s| yield server(s)}
    51:     end

empty?() click to toggle source

Returns true if no records exist in the dataset, false otherwise

      DB[:table].empty? # SELECT 1 AS one FROM table LIMIT 1
      # => false

         # File lib/sequel/dataset/actions.rb, line 142
    142:     def empty?
    143:       get(Sequel::SQL::AliasedExpression.new(1, :one)).nil?
    144:     end

eql?(o) click to toggle source

Alias for ==

        # File lib/sequel/dataset/misc.rb, line 40
    40:     def eql?(o)
    41:       self == o
    42:     end

except(dataset, opts={}) click to toggle source

Adds an EXCEPT clause using a second dataset object. An EXCEPT compound dataset returns all rows in the current dataset that are not in the given dataset. Raises an `InvalidOperation` if the operation is not supported. Options:

:alias | Use the given value as the from_self alias
:all | Set to true to use EXCEPT ALL instead of EXCEPT, so duplicate rows can occur
:from_self | Set to false to not wrap the returned dataset in a from_self, use with care.

      DB[:items].except(DB[:other_items])
      # SELECT * FROM (SELECT * FROM items EXCEPT SELECT * FROM other_items) AS t1

      DB[:items].except(DB[:other_items], :all=>true, :from_self=>false)
      # SELECT * FROM items EXCEPT ALL SELECT * FROM other_items

      DB[:items].except(DB[:other_items], :alias=>:i)
      # SELECT * FROM (SELECT * FROM items EXCEPT SELECT * FROM other_items) AS i

        # File lib/sequel/dataset/query.rb, line 92
    92:     def except(dataset, opts={})
    93:       opts = {:all=>opts} unless opts.is_a?(Hash)
    94:       raise(InvalidOperation, "EXCEPT not supported") unless supports_intersect_except?
    95:       raise(InvalidOperation, "EXCEPT ALL not supported") if opts[:all] && !supports_intersect_except_all?
    96:       compound_clone(:except, dataset, opts)
    97:     end

exclude(*cond, &block) click to toggle source

Performs the inverse of Dataset#filter. Note that if you have multiple filter conditions, this is not the same as a negation of all conditions.

      DB[:items].exclude(:category => 'software')
      # SELECT * FROM items WHERE (category != 'software')

      DB[:items].exclude(:category => 'software', :id=>3)
      # SELECT * FROM items WHERE ((category != 'software') OR (id != 3))

         # File lib/sequel/dataset/query.rb, line 107
    107:     def exclude(*cond, &block)
    108:       _filter_or_exclude(true, @opts[:having] ? :having : :where, *cond, &block)
    109:     end

exclude_having(*cond, &block) click to toggle source

Inverts the given conditions and adds them to the HAVING clause.

      DB[:items].select_group(:name).exclude_having{count(name) < 2}
      # SELECT name FROM items GROUP BY name HAVING (count(name) >= 2)

         # File lib/sequel/dataset/query.rb, line 115
    115:     def exclude_having(*cond, &block)
    116:       _filter_or_exclude(true, :having, *cond, &block)
    117:     end

exclude_where(*cond, &block) click to toggle source

Inverts the given conditions and adds them to the WHERE clause.

      DB[:items].select_group(:name).exclude_where(:category => 'software')
      # SELECT * FROM items WHERE (category != 'software')

      DB[:items].select_group(:name).
        exclude_having{count(name) < 2}.
        exclude_where(:category => 'software')
      # SELECT name FROM items WHERE (category != 'software')
      # GROUP BY name HAVING (count(name) >= 2)

         # File lib/sequel/dataset/query.rb, line 129
    129:     def exclude_where(*cond, &block)
    130:       _filter_or_exclude(true, :where, *cond, &block)
    131:     end

exists() click to toggle source

Returns an EXISTS clause for the dataset as a `LiteralString`.

      DB.select(1).where(DB[:items].exists)
      # SELECT 1 WHERE (EXISTS (SELECT * FROM items))

        # File lib/sequel/dataset/sql.rb, line 22
    22:     def exists
    23:       SQL::PlaceholderLiteralString.new("EXISTS ?", [self], true)
    24:     end

fetch_rows(sql, &block) click to toggle source

Yield all rows matching this dataset. If the dataset is set to split multiple statements, yield arrays of hashes one per statement instead of yielding results for all statements as hashes.

         # File lib/sequel/adapters/mysql.rb, line 284
    284:       def fetch_rows(sql, &block)
    285:         execute(sql) do |r|
    286:           i = 1
    287:           cps = db.conversion_procs
    288:           cols = r.fetch_fields.map do |f|
    289:             # Pretend tinyint is another integer type if its length is not 1, to
    290:             # avoid casting to boolean if Sequel::MySQL.convert_tinyint_to_bool
    291:             # is set.
    292:             type_proc = f.type == 1 && f.length != 1 ? cps[2] : cps[f.type]
    293:             [output_identifier(f.name), type_proc, i+=1]
    294:           end
    295:           @columns = cols.map{|c| c.first}
    296:           if opts[:split_multiple_result_sets]
    297:             s = []
    298:             yield_rows(r, cols){|h| s << h}
    299:             yield s
    300:           else
    301:             yield_rows(r, cols, &block)
    302:           end
    303:         end
    304:         self
    305:       end

fetch_rows(sql, &block) click to toggle source

Yield all rows returned by executing the given SQL and converting the types.

         # File lib/sequel/adapters/postgres.rb, line 484
    484:       def fetch_rows(sql, &block)
    485:         return cursor_fetch_rows(sql, &block) if @opts[:cursor]
    486:         execute(sql){|res| yield_hash_rows(res, fetch_rows_set_cols(res), &block)}
    487:       end

fetch_rows(sql) click to toggle source

         # File lib/sequel/adapters/oracle.rb, line 380
    380:       def fetch_rows(sql)
    381:         execute(sql) do |cursor|
    382:           offset = @opts[:offset]
    383:           rn = row_number_column
    384:           cps = db.conversion_procs
    385:           cols = columns = cursor.get_col_names.map{|c| output_identifier(c)}
    386:           metadata = cursor.column_metadata
    387:           cm = cols.zip(metadata).map{|c, m| [c, cps[m.data_type]]}
    388:           columns = cols.reject{|x| x == rn} if offset
    389:           @columns = columns
    390:           while r = cursor.fetch
    391:             row = {}
    392:             r.zip(cm).each{|v, (c, cp)| row[c] = ((v && cp) ? cp.call(v) : v)}
    393:             row.delete(rn) if offset
    394:             yield row
    395:           end
    396:         end
    397:         self
    398:       end

fetch_rows(sql) click to toggle source

Executes a select query and fetches records, yielding each record to the supplied block. The yielded records should be hashes with symbol keys. This method should probably should not be called by user code, use `each` instead.

         # File lib/sequel/dataset/actions.rb, line 150
    150:     def fetch_rows(sql)
    151:       raise NotImplemented, NOTIMPL_MSG
    152:     end

fetch_rows(sql, &block) click to toggle source

Correctly return rows from the database and return them as hashes.

         # File lib/sequel/adapters/jdbc.rb, line 594
    594:       def fetch_rows(sql, &block)
    595:         execute(sql){|result| process_result_set(result, &block)}
    596:         self
    597:       end

filter(*cond, &block) click to toggle source

Returns a copy of the dataset with the given conditions imposed upon it. If the query already has a HAVING clause, then the conditions are imposed in the HAVING clause. If not, then they are imposed in the WHERE clause.

filter accepts the following argument types:

- Hash - list of equality/inclusion expressions

- Array - depends:

  - If first member is a string, assumes the rest of the arguments are parameters and interpolates them into the string.

  - If all members are arrays of length two, treats the same way as a hash, except it allows for duplicate keys to be specified.

  - Otherwise, treats each argument as a separate condition.

- String - taken literally

- Symbol - taken as a boolean column argument (e.g. WHERE active)

- Sequel::SQL::BooleanExpression - an existing condition expression, probably created using the Sequel expression filter DSL.

filter also takes a block, which should return one of the above argument types, and is treated the same way. This block yields a virtual row object, which is easy to use to create identifiers and functions. For more details on the virtual row support, see the "Virtual Rows" guide

If both a block and regular argument are provided, they get ANDed together.

Examples:

      DB[:items].filter(:id => 3)
      # SELECT * FROM items WHERE (id = 3)

      DB[:items].filter('price < ?', 100)
      # SELECT * FROM items WHERE price < 100

      DB[:items].filter([[:id, (1,2,3)], [:id, 0..10]])
      # SELECT * FROM items WHERE ((id IN (1, 2, 3)) AND ((id >= 0) AND (id <= 10)))

      DB[:items].filter('price < 100')
      # SELECT * FROM items WHERE price < 100

      DB[:items].filter(:active)
      # SELECT * FROM items WHERE :active

      DB[:items].filter{price < 100}
      # SELECT * FROM items WHERE (price < 100)

Multiple filter calls can be chained for scoping:

      software = dataset.filter(:category => 'software').filter{price < 100}
      # SELECT * FROM items WHERE ((category = 'software') AND (price < 100))

See the the "Dataset Filtering" guide for more examples and details.

         # File lib/sequel/dataset/query.rb, line 185
    185:     def filter(*cond, &block)
    186:       _filter(@opts[:having] ? :having : :where, *cond, &block)
    187:     end

first(*args, &block) click to toggle source

If a integer argument is given, it is interpreted as a limit, and then returns all matching records up to that limit. If no argument is passed, it returns the first matching record. If any other type of argument(s) is passed, it is given to filter and the first matching record is returned. If a block is given, it is used to filter the dataset before returning anything. Examples:

      DB[:table].first # SELECT * FROM table LIMIT 1
      # => {:id=>7}

      DB[:table].first(2) # SELECT * FROM table LIMIT 2
      # => [{:id=>6}, {:id=>4}]

      DB[:table].first(:id=>2) # SELECT * FROM table WHERE (id = 2) LIMIT 1
      # => {:id=>2}

      DB[:table].first("id = 3") # SELECT * FROM table WHERE (id = 3) LIMIT 1
      # => {:id=>3}

      DB[:table].first("id = ?", 4) # SELECT * FROM table WHERE (id = 4) LIMIT 1
      # => {:id=>4}

      DB[:table].first{id > 2} # SELECT * FROM table WHERE (id > 2) LIMIT 1
      # => {:id=>5}

      DB[:table].first("id > ?", 4){id < 6} # SELECT * FROM table WHERE ((id > 4) AND (id < 6)) LIMIT 1
      # => {:id=>5}

      DB[:table].first(2){id < 2} # SELECT * FROM table WHERE (id < 2) LIMIT 2
      # => [{:id=>1}]

         # File lib/sequel/dataset/actions.rb, line 184
    184:     def first(*args, &block)
    185:       ds = block ? filter(&block) : self
    186:
    187:       if args.empty?
    188:         ds.single_record
    189:       else
    190:         args = (args.size == 1) ? args.first : args
    191:         if Integer === args
    192:           ds.limit(args).all
    193:         else
    194:           ds.filter(args).single_record
    195:         end
    196:       end
    197:     end

first_source() click to toggle source

Alias of `first_source_alias`

        # File lib/sequel/dataset/misc.rb, line 54
    54:     def first_source
    55:       first_source_alias
    56:     end

first_source_alias() click to toggle source

The first source (primary table) for this dataset. If the dataset doesn’t have a table, raises an `Error`. If the table is aliased, returns the aliased name.

      DB[:table].first_source_alias
      # => :table

      DB[:table___t].first_source_alias
      # => :t

        # File lib/sequel/dataset/misc.rb, line 66
    66:     def first_source_alias
    67:       source = @opts[:from]
    68:       if source.nil? || source.empty?
    69:         raise Error, 'No source specified for query'
    70:       end
    71:       case s = source.first
    72:       when SQL::AliasedExpression
    73:         s.aliaz
    74:       when Symbol
    75:         sch, table, aliaz = split_symbol(s)
    76:         aliaz ? aliaz.to_sym : s
    77:       else
    78:         s
    79:       end
    80:     end

first_source_table() click to toggle source

The first source (primary table) for this dataset. If the dataset doesn’t have a table, raises an error. If the table is aliased, returns the original table, not the alias

      DB[:table].first_source_table
      # => :table

      DB[:table___t].first_source_table
      # => :table

         # File lib/sequel/dataset/misc.rb, line 91
     91:     def first_source_table
     92:       source = @opts[:from]
     93:       if source.nil? || source.empty?
     94:         raise Error, 'No source specified for query'
     95:       end
     96:       case s = source.first
     97:       when SQL::AliasedExpression
     98:         s.expression
     99:       when Symbol
    100:         sch, table, aliaz = split_symbol(s)
    101:         aliaz ? (sch ? SQL::QualifiedIdentifier.new(sch, table) : table.to_sym) : s
    102:       else
    103:         s
    104:       end
    105:     end

for_update() click to toggle source

Returns a cloned dataset with a :update lock style.

      DB[:table].for_update # SELECT * FROM table FOR UPDATE

         # File lib/sequel/dataset/query.rb, line 192
    192:     def for_update
    193:       lock_style(:update)
    194:     end

from(*source) click to toggle source

Returns a copy of the dataset with the source changed. If no source is given, removes all tables. If multiple sources are given, it is the same as using a CROSS JOIN (cartesian product) between all tables.

      DB[:items].from # SQL: SELECT *
      DB[:items].from(:blah) # SQL: SELECT * FROM blah
      DB[:items].from(:blah, :foo) # SQL: SELECT * FROM blah, foo

         # File lib/sequel/dataset/query.rb, line 203
    203:     def from(*source)
    204:       table_alias_num = 0
    205:       sources = []
    206:       ctes = nil
    207:       source.each do |s|
    208:         case s
    209:         when Hash
    210:           s.each{|k,v| sources << SQL::AliasedExpression.new(k,v)}
    211:         when Dataset
    212:           if hoist_cte?(s)
    213:             ctes ||= []
    214:             ctes += s.opts[:with]
    215:             s = s.clone(:with=>nil)
    216:           end
    217:           sources << SQL::AliasedExpression.new(s, dataset_alias(table_alias_num+=1))
    218:         when Symbol
    219:           sch, table, aliaz = split_symbol(s)
    220:           if aliaz
    221:             s = sch ? SQL::QualifiedIdentifier.new(sch, table) : SQL::Identifier.new(table)
    222:             sources << SQL::AliasedExpression.new(s, aliaz.to_sym)
    223:           else
    224:             sources << s
    225:           end
    226:         else
    227:           sources << s
    228:         end
    229:       end
    230:       o = {:from=>sources.empty? ? nil : sources}
    231:       o[:with] = (opts[:with] || []) + ctes if ctes
    232:       o[:num_dataset_sources] = table_alias_num if table_alias_num > 0
    233:       clone(o)
    234:     end

from_self(opts={}) click to toggle source

Returns a dataset selecting from the current dataset. Supplying the :alias option controls the alias of the result.

      ds = DB[:items].order(:name).select(:id, :name)
      # SELECT id,name FROM items ORDER BY name

      ds.from_self
      # SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS t1

      ds.from_self(:alias=>:foo)
      # SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS foo

         # File lib/sequel/dataset/query.rb, line 247
    247:     def from_self(opts={})
    248:       fs = {}
    249:       @opts.keys.each{|k| fs[k] = nil unless NON_SQL_OPTIONS.include?(k)}
    250:       clone(fs).from(opts[:alias] ? as(opts[:alias]) : self)
    251:     end

function_sql_append(sql, f) click to toggle source

SQL fragment specifying an SQL function call

         # File lib/sequel/dataset/sql.rb, line 496
    496:     def function_sql_append(sql, f)
    497:       sql << f.f.to_s
    498:       args = f.args
    499:       if args.empty?
    500:         sql << FUNCTION_EMPTY
    501:       else
    502:         literal_append(sql, args)
    503:       end
    504:     end

get(column=nil, &block) click to toggle source

Return the column value for the first matching record in the dataset. Raises an error if both an argument and block is given.

      DB[:table].get(:id) # SELECT id FROM table LIMIT 1
      # => 3

      ds.get{sum(id)} # SELECT sum(id) FROM table LIMIT 1
      # => 6

         # File lib/sequel/dataset/actions.rb, line 207
    207:     def get(column=nil, &block)
    208:       if column
    209:         raise(Error, ARG_BLOCK_ERROR_MSG) if block
    210:         select(column).single_value
    211:       else
    212:         select(&block).single_value
    213:       end
    214:     end

graph(dataset, join_conditions = nil, options = {}, &block) click to toggle source

Allows you to join multiple datasets/tables and have the result set split into component tables.

This differs from the usual usage of join, which returns the result set as a single hash. For example:

      # CREATE TABLE artists (id INTEGER, name TEXT);
      # CREATE TABLE albums (id INTEGER, name TEXT, artist_id INTEGER);

      DB[:artists].left_outer_join(:albums, :artist_id=>:id).first
      #=> {:id=>albums.id, :name=>albums.name, :artist_id=>albums.artist_id}

      DB[:artists].graph(:albums, :artist_id=>:id).first
      #=> {:artists=>{:id=>artists.id, :name=>artists.name}, :albums=>{:id=>albums.id, :name=>albums.name, :artist_id=>albums.artist_id}}

Using a join such as left_outer_join, the attribute names that are shared between the tables are combined in the single return hash. You can get around that by using `select` with correct aliases for all of the columns, but it is simpler to use `graph` and have the result set split for you. In addition, `graph` respects any `row_proc` of the current dataset and the datasets you use with `graph`.

If you are graphing a table and all columns for that table are nil, this indicates that no matching rows existed in the table, so graph will return nil instead of a hash with all nil values:

      # If the artist doesn't have any albums
      DB[:artists].graph(:albums, :artist_id=>:id).first
      => {:artists=>{:id=>artists.id, :name=>artists.name}, :albums=>nil}

Arguments:

dataset | Can be a symbol (specifying a table), another dataset, or an object that responds to `dataset` and returns a symbol or a dataset
join_conditions | Any condition(s) allowed by `join_table`.
block | A block that is passed to `join_table`.

Options:

:from_self_alias | The alias to use when the receiver is not a graphed dataset but it contains multiple FROM tables or a JOIN. In this case, the receiver is wrapped in a from_self before graphing, and this option determines the alias to use.
:implicit_qualifier | The qualifier of implicit conditions, see #.
:join_type | The type of join to use (passed to `join_table`). Defaults to :left_outer.
:select | An array of columns to select. When not used, selects all columns in the given dataset. When set to false, selects no columns and is like simply joining the tables, though graph keeps some metadata about the join that makes it important to use `graph` instead of `join_table`.
:table_alias | The alias to use for the table. If not specified, doesn’t alias the table. You will get an error if the the alias (or table) name is used more than once.

         # File lib/sequel/dataset/graph.rb, line 74
     74:     def graph(dataset, join_conditions = nil, options = {}, &block)
     75:       # Allow the use of a model, dataset, or symbol as the first argument
     76:       # Find the table name/dataset based on the argument
     77:       dataset = dataset.dataset if dataset.respond_to?(:dataset)
     78:       table_alias = options[:table_alias]
     79:       case dataset
     80:       when Symbol
     81:         table = dataset
     82:         dataset = @db[dataset]
     83:         table_alias ||= table
     84:       when ::Sequel::Dataset
     85:         if dataset.simple_select_all?
     86:           table = dataset.opts[:from].first
     87:           table_alias ||= table
     88:         else
     89:           table = dataset
     90:           table_alias ||= dataset_alias((@opts[:num_dataset_sources] || 0)+1)
     91:         end
     92:       else
     93:         raise Error, "The dataset argument should be a symbol, dataset, or model"
     94:       end
     95:
     96:       # Raise Sequel::Error with explanation that the table alias has been used
     97:       raise_alias_error = lambda do
     98:         raise(Error, "this #{options[:table_alias] ? 'alias' : 'table'} has already been been used, please specify "            "#{options[:table_alias] ? 'a different alias' : 'an alias via the :table_alias option'}")
     99:       end
    100:
    101:       # Only allow table aliases that haven't been used
    102:       raise_alias_error.call if @opts[:graph] && @opts[:graph][:table_aliases] && @opts[:graph][:table_aliases].include?(table_alias)
    103:
    104:       # Use a from_self if this is already a joined table
    105:       ds = (!@opts[:graph] && (@opts[:from].length > 1 || @opts[:join])) ? from_self(:alias=>options[:from_self_alias] || first_source) : self
    106:
    107:       # Join the table early in order to avoid cloning the dataset twice
    108:       ds = ds.join_table(options[:join_type] || :left_outer, table, join_conditions, :table_alias=>table_alias, :implicit_qualifier=>options[:implicit_qualifier], &block)
    109:       opts = ds.opts
    110:
    111:       # Whether to include the table in the result set
    112:       add_table = options[:select] == false ? false : true
    113:       # Whether to add the columns to the list of column aliases
    114:       add_columns = !ds.opts.include?(:graph_aliases)
    115:
    116:       # Setup the initial graph data structure if it doesn't exist
    117:       if graph = opts[:graph]
    118:         opts[:graph] = graph = graph.dup
    119:         select = opts[:select].dup
    120:         [:column_aliases, :table_aliases, :column_alias_num].each{|k| graph[k] = graph[k].dup}
    121:       else
    122:         master = alias_symbol(ds.first_source_alias)
    123:         raise_alias_error.call if master == table_alias
    124:         # Master hash storing all .graph related information
    125:         graph = opts[:graph] = {}
    126:         # Associates column aliases back to tables and columns
    127:         column_aliases = graph[:column_aliases] = {}
    128:         # Associates table alias (the master is never aliased)
    129:         table_aliases = graph[:table_aliases] = {master=>self}
    130:         # Keep track of the alias numbers used
    131:         ca_num = graph[:column_alias_num] = Hash.new(0)
    132:         # All columns in the master table are never
    133:         # aliased, but are not included if set_graph_aliases
    134:         # has been used.
    135:         if add_columns
    136:           if (select = @opts[:select]) && !select.empty? && !(select.length == 1 && (select.first.is_a?(SQL::ColumnAll)))
    137:             select = select.each do |sel|
    138:               column = case sel
    139:               when Symbol
    140:                 _, c, a = split_symbol(sel)
    141:                 (a || c).to_sym
    142:               when SQL::Identifier
    143:                 sel.value.to_sym
    144:               when SQL::QualifiedIdentifier
    145:                 column = sel.column
    146:                 column = column.value if column.is_a?(SQL::Identifier)
    147:                 column.to_sym
    148:               when SQL::AliasedExpression
    149:                 column = sel.aliaz
    150:                 column = column.value if column.is_a?(SQL::Identifier)
    151:                 column.to_sym
    152:               else
    153:                 raise Error, "can't figure out alias to use for graphing for #{sel.inspect}"
    154:               end
    155:               column_aliases[column] = [master, column]
    156:             end
    157:             select = qualified_expression(select, master)
    158:           else
    159:             select = columns.map do |column|
    160:               column_aliases[column] = [master, column]
    161:               SQL::QualifiedIdentifier.new(master, column)
    162:             end
    163:           end
    164:         end
    165:       end
    166:
    167:       # Add the table alias to the list of aliases
    168:       # Even if it isn't been used in the result set,
    169:       # we add a key for it with a nil value so we can check if it
    170:       # is used more than once
    171:       table_aliases = graph[:table_aliases]
    172:       table_aliases[table_alias] = add_table ? dataset : nil
    173:
    174:       # Add the columns to the selection unless we are ignoring them
    175:       if add_table && add_columns
    176:         column_aliases = graph[:column_aliases]
    177:         ca_num = graph[:column_alias_num]
    178:         # Which columns to add to the result set
    179:         cols = options[:select] || dataset.columns
    180:         # If the column hasn't been used yet, don't alias it.
    181:         # If it has been used, try table_column.
    182:         # If that has been used, try table_column_N
    183:         # using the next value of N that we know hasn't been
    184:         # used
    185:         cols.each do |column|
    186:           col_alias, identifier = if column_aliases[column]
    187:             column_alias = :"#{table_alias}_#{column}"
    188:             if column_aliases[column_alias]
    189:               column_alias_num = ca_num[column_alias]
    190:               column_alias = :"#{column_alias}_#{column_alias_num}"
    191:               ca_num[column_alias] += 1
    192:             end
    193:             [column_alias, SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(table_alias, column), column_alias)]
    194:           else
    195:             ident = SQL::QualifiedIdentifier.new(table_alias, column)
    196:             [column, ident]
    197:           end
    198:           column_aliases[col_alias] = [table_alias, column]
    199:           select.push(identifier)
    200:         end
    201:       end
    202:       add_columns ? ds.select(*select) : ds
    203:     end

graph(*) click to toggle source

Don’t allow graphing a dataset that splits multiple statements

         # File lib/sequel/adapters/mysql.rb, line 308
    308:       def graph(*)
    309:         raise(Error, "Can't graph a dataset that splits multiple result sets") if opts[:split_multiple_result_sets]
    310:         super
    311:       end

grep(columns, patterns, opts={}) click to toggle source

Match any of the columns to any of the patterns. The terms can be strings (which use LIKE) or regular expressions (which are only supported on MySQL and PostgreSQL). Note that the total number of pattern matches will be Array(columns).length * Array(terms).length, which could cause performance issues.

Options (all are boolean):

:all_columns | All columns must be matched to any of the given patterns.
:all_patterns | All patterns must match at least one of the columns.
:case_insensitive | Use a case insensitive pattern match (the default is case sensitive if the database supports it).

If both :all_columns and :all_patterns are true, all columns must match all patterns.

Examples:

      dataset.grep(:a, '%test%')
      # SELECT * FROM items WHERE (a LIKE '%test%')

      dataset.grep([:a, :b], %w'%test% foo')
      # SELECT * FROM items WHERE ((a LIKE '%test%') OR (a LIKE 'foo') OR (b LIKE '%test%') OR (b LIKE 'foo'))

      dataset.grep([:a, :b], %w'%foo% %bar%', :all_patterns=>true)
      # SELECT * FROM a WHERE (((a LIKE '%foo%') OR (b LIKE '%foo%')) AND ((a LIKE '%bar%') OR (b LIKE '%bar%')))

      dataset.grep([:a, :b], %w'%foo% %bar%', :all_columns=>true)
      # SELECT * FROM a WHERE (((a LIKE '%foo%') OR (a LIKE '%bar%')) AND ((b LIKE '%foo%') OR (b LIKE '%bar%')))

      dataset.grep([:a, :b], %w'%foo% %bar%', :all_patterns=>true, :all_columns=>true)
      # SELECT * FROM a WHERE ((a LIKE '%foo%') AND (b LIKE '%foo%') AND (a LIKE '%bar%') AND (b LIKE '%bar%'))

         # File lib/sequel/dataset/query.rb, line 284
    284:     def grep(columns, patterns, opts={})
    285:       if opts[:all_patterns]
    286:         conds = Array(patterns).map do |pat|
    287:           SQL::BooleanExpression.new(opts[:all_columns] ? :AND : :OR, *Array(columns).map{|c| SQL::StringExpression.like(c, pat, opts)})
    288:         end
    289:         filter(SQL::BooleanExpression.new(opts[:all_patterns] ? :AND : :OR, *conds))
    290:       else
    291:         conds = Array(columns).map do |c|
    292:           SQL::BooleanExpression.new(:OR, *Array(patterns).map{|pat| SQL::StringExpression.like(c, pat, opts)})
    293:         end
    294:         filter(SQL::BooleanExpression.new(opts[:all_columns] ? :AND : :OR, *conds))
    295:       end
    296:     end

group(*columns, &block) click to toggle source

Returns a copy of the dataset with the results grouped by the value of the given columns. If a block is given, it is treated as a virtual row block, similar to `filter`.

      DB[:items].group(:id) # SELECT * FROM items GROUP BY id
      DB[:items].group(:id, :name) # SELECT * FROM items GROUP BY id, name
      DB[:items].group{[a, sum(b)]} # SELECT * FROM items GROUP BY a, sum(b)

         # File lib/sequel/dataset/query.rb, line 305
    305:     def group(*columns, &block)
    306:       virtual_row_columns(columns, block)
    307:       clone(:group => (columns.compact.empty? ? nil : columns))
    308:     end

group_and_count(*columns, &block) click to toggle source

Returns a dataset grouped by the given column with count by group. Column aliases may be supplied, and will be included in the select clause. If a block is given, it is treated as a virtual row block, similar to `filter`.

Examples:

      DB[:items].group_and_count(:name).all
      # SELECT name, count(*) AS count FROM items GROUP BY name
      # => [{:name=>'a', :count=>1}, ...]

      DB[:items].group_and_count(:first_name, :last_name).all
      # SELECT first_name, last_name, count(*) AS count FROM items GROUP BY first_name, last_name
      # => [{:first_name=>'a', :last_name=>'b', :count=>1}, ...]

      DB[:items].group_and_count(:first_name___name).all
      # SELECT first_name AS name, count(*) AS count FROM items GROUP BY first_name
      # => [{:name=>'a', :count=>1}, ...]

      DB[:items].group_and_count{substr(first_name, 1, 1).as(initial)}.all
      # SELECT substr(first_name, 1, 1) AS initial, count(*) AS count FROM items GROUP BY substr(first_name, 1, 1)
      # => [{:initial=>'a', :count=>1}, ...]

         # File lib/sequel/dataset/query.rb, line 336
    336:     def group_and_count(*columns, &block)
    337:       select_group(*columns, &block).select_more(COUNT_OF_ALL_AS_COUNT)
    338:     end

group_by(*columns, &block) click to toggle source

Alias of group

         # File lib/sequel/dataset/query.rb, line 311
    311:     def group_by(*columns, &block)
    312:       group(*columns, &block)
    313:     end

group_cube() click to toggle source

Adds the appropriate CUBE syntax to GROUP BY.

         # File lib/sequel/dataset/query.rb, line 341
    341:     def group_cube
    342:       raise Error, "GROUP BY CUBE not supported on #{db.database_type}" unless supports_group_cube?
    343:       clone(:group_options=>:cube)
    344:     end

group_rollup() click to toggle source

Adds the appropriate ROLLUP syntax to GROUP BY.

         # File lib/sequel/dataset/query.rb, line 347
    347:     def group_rollup
    348:       raise Error, "GROUP BY ROLLUP not supported on #{db.database_type}" unless supports_group_rollup?
    349:       clone(:group_options=>:rollup)
    350:     end

hash() click to toggle source

Define a hash value such that datasets with the same DB, opts, and SQL will have the same hash value

         # File lib/sequel/dataset/misc.rb, line 109
    109:     def hash
    110:       [db, opts.sort_by{|k, v| k.to_s}, sql].hash
    111:     end

having(*cond, &block) click to toggle source

Returns a copy of the dataset with the HAVING conditions changed. See # for argument types.

      DB[:items].group(:sum).having(:sum=>10)
      # SELECT * FROM items GROUP BY sum HAVING (sum = 10)

         # File lib/sequel/dataset/query.rb, line 356
    356:     def having(*cond, &block)
    357:       _filter(:having, *cond, &block)
    358:     end

identifier_input_method() click to toggle source

The String instance method to call on identifiers before sending them to the database.

         # File lib/sequel/dataset/misc.rb, line 115
    115:     def identifier_input_method
    116:       if defined?(@identifier_input_method)
    117:         @identifier_input_method
    118:       elsif db.respond_to?(:identifier_input_method)
    119:         @identifier_input_method = db.identifier_input_method
    120:       else
    121:         @identifier_input_method = nil
    122:       end
    123:     end

identifier_output_method() click to toggle source

The String instance method to call on identifiers before sending them to the database.

         # File lib/sequel/dataset/misc.rb, line 127
    127:     def identifier_output_method
    128:       if defined?(@identifier_output_method)
    129:         @identifier_output_method
    130:       elsif db.respond_to?(:identifier_output_method)
    131:         @identifier_output_method = db.identifier_output_method
    132:       else
    133:         @identifier_output_method = nil
    134:       end
    135:     end

import(columns, values, opts={}) click to toggle source

Inserts multiple records into the associated table. This method can be used to efficiently insert a large number of records into a table in a single query if the database supports it. Inserts are automatically wrapped in a transaction.

This method is called with a columns array and an array of value arrays:

      DB[:table].import([:x, :y], [[1, 2], [3, 4]])
      # INSERT INTO table (x, y) VALUES (1, 2)
      # INSERT INTO table (x, y) VALUES (3, 4)

This method also accepts a dataset instead of an array of value arrays:

      DB[:table].import([:x, :y], DB[:table2].select(:a, :b))
      # INSERT INTO table (x, y) SELECT a, b FROM table2

Options:

:commit_every | Open a new transaction for every given number of records. For example, if you provide a value of 50, will commit after every 50 records.
:server | Set the server/shard to use for the transaction and insert queries.
:slice | Same as :commit_every, :commit_every takes precedence.

         # File lib/sequel/dataset/actions.rb, line 239
    239:     def import(columns, values, opts={})
    240:       return @db.transaction{insert(columns, values)} if values.is_a?(Dataset)
    241:
    242:       return if values.empty?
    243:       raise(Error, IMPORT_ERROR_MSG) if columns.empty?
    244:       ds = opts[:server] ? server(opts[:server]) : self
    245:
    246:       if slice_size = opts[:commit_every] || opts[:slice]
    247:         offset = 0
    248:         rows = []
    249:         while offset < values.length
    250:           rows << ds._import(columns, values[offset, slice_size], opts)
    251:           offset += slice_size
    252:         end
    253:         rows.flatten
    254:       else
    255:         ds._import(columns, values, opts)
    256:       end
    257:     end

insert(*values) click to toggle source

Insert a new value into this dataset

         # File lib/sequel/adapters/mysql.rb, line 314
    314:       def insert(*values)
    315:         execute_dui(insert_sql(*values)){|c| return c.insert_id}
    316:       end

insert(*values, &block) click to toggle source

Inserts values into the associated table. The returned value is generally the value of the primary key for the inserted row, but that is adapter dependent.

`insert` handles a number of different argument formats:

no arguments or single empty hash | Uses DEFAULT VALUES
single hash | Most common format, treats keys as columns an values as values
single array | Treats entries as values, with no columns
two arrays | Treats first array as columns, second array as values
single Dataset | Treats as an insert based on a selection from the dataset given, with no columns
array and dataset | Treats as an insert based on a selection from the dataset given, with the columns given by the array.

Examples:

      DB[:items].insert
      # INSERT INTO items DEFAULT VALUES

      DB[:items].insert({})
      # INSERT INTO items DEFAULT VALUES

      DB[:items].insert([1,2,3])
      # INSERT INTO items VALUES (1, 2, 3)

      DB[:items].insert([:a, :b], [1,2])
      # INSERT INTO items (a, b) VALUES (1, 2)

      DB[:items].insert(:a => 1, :b => 2)
      # INSERT INTO items (a, b) VALUES (1, 2)

      DB[:items].insert(DB[:old_items])
      # INSERT INTO items SELECT * FROM old_items

      DB[:items].insert([:a, :b], DB[:old_items])
      # INSERT INTO items (a, b) SELECT * FROM old_items

         # File lib/sequel/dataset/actions.rb, line 294
    294:     def insert(*values, &block)
    295:       sql = insert_sql(*values)
    296:       if uses_returning?(:insert)
    297:         returning_fetch_rows(sql, &block)
    298:       else
    299:         execute_insert(sql)
    300:       end
    301:     end

insert_multiple(array, &block) click to toggle source

Inserts multiple values. If a block is given it is invoked for each item in the given array before inserting it. See `multi_insert` as a possibly faster version that may be able to insert multiple records in one SQL statement (if supported by the database). Returns an array of primary keys of inserted rows.

      DB[:table].insert_multiple([{:x=>1}, {:x=>2}])
      # => [4, 5]
      # INSERT INTO table (x) VALUES (1)
      # INSERT INTO table (x) VALUES (2)

      DB[:table].insert_multiple([{:x=>1}, {:x=>2}]){|row| row[:y] = row[:x] * 2}
      # => [6, 7]
      # INSERT INTO table (x, y) VALUES (1, 2)
      # INSERT INTO table (x, y) VALUES (2, 4)

         # File lib/sequel/dataset/actions.rb, line 318
    318:     def insert_multiple(array, &block)
    319:       if block
    320:         array.map{|i| insert(block.call(i))}
    321:       else
    322:         array.map{|i| insert(i)}
    323:       end
    324:     end

insert_sql(*values) click to toggle source

Returns an INSERT SQL query string. See `insert`.

      DB[:items].insert_sql(:a=>1)
      # => "INSERT INTO items (a) VALUES (1)"

        # File lib/sequel/dataset/sql.rb, line 30
    30:     def insert_sql(*values)
    31:       return static_sql(@opts[:sql]) if @opts[:sql]
    32:
    33:       check_modification_allowed!
    34:
    35:       columns = []
    36:
    37:       case values.size
    38:       when 0
    39:         return insert_sql({})
    40:       when 1
    41:         case vals = values.at(0)
    42:         when Hash
    43:           vals = @opts[:defaults].merge(vals) if @opts[:defaults]
    44:           vals = vals.merge(@opts[:overrides]) if @opts[:overrides]
    45:           values = []
    46:           vals.each do |k,v|
    47:             columns << k
    48:             values << v
    49:           end
    50:         when Dataset, Array, LiteralString
    51:           values = vals
    52:         else
    53:           if vals.respond_to?(:values) && (v = vals.values).is_a?(Hash)
    54:             return insert_sql(v)
    55:           end
    56:         end
    57:       when 2
    58:         if (v0 = values.at(0)).is_a?(Array) && ((v1 = values.at(1)).is_a?(Array) || v1.is_a?(Dataset) || v1.is_a?(LiteralString))
    59:           columns, values = v0, v1
    60:           raise(Error, "Different number of values and columns given to insert_sql") if values.is_a?(Array) and columns.length != values.length
    61:         end
    62:       end
    63:
    64:       if values.is_a?(Array) && values.empty? && !insert_supports_empty_values?
    65:         columns = [columns().last]
    66:         values = ['DEFAULT'.lit]
    67:       end
    68:       clone(:columns=>columns, :values=>values)._insert_sql
    69:     end

inspect() click to toggle source

Returns a string representation of the dataset including the class name and the corresponding SQL select statement.

         # File lib/sequel/dataset/misc.rb, line 139
    139:     def inspect
    140:       c = self.class
    141:       c = c.superclass while c.name.nil? || c.name == ''
    142:       "#<#{c.name}: #{sql.inspect}>"
    143:     end

intersect(dataset, opts={}) click to toggle source

Adds an INTERSECT clause using a second dataset object. An INTERSECT compound dataset returns all rows in both the current dataset and the given dataset. Raises an `InvalidOperation` if the operation is not supported. Options:

:alias | Use the given value as the from_self alias
:all | Set to true to use INTERSECT ALL instead of INTERSECT, so duplicate rows can occur
:from_self | Set to false to not wrap the returned dataset in a from_self, use with care.

      DB[:items].intersect(DB[:other_items])
      # SELECT * FROM (SELECT * FROM items INTERSECT SELECT * FROM other_items) AS t1

      DB[:items].intersect(DB[:other_items], :all=>true, :from_self=>false)
      # SELECT * FROM items INTERSECT ALL SELECT * FROM other_items

      DB[:items].intersect(DB[:other_items], :alias=>:i)
      # SELECT * FROM (SELECT * FROM items INTERSECT SELECT * FROM other_items) AS i

         # File lib/sequel/dataset/query.rb, line 377
    377:     def intersect(dataset, opts={})
    378:       opts = {:all=>opts} unless opts.is_a?(Hash)
    379:       raise(InvalidOperation, "INTERSECT not supported") unless supports_intersect_except?
    380:       raise(InvalidOperation, "INTERSECT ALL not supported") if opts[:all] && !supports_intersect_except_all?
    381:       compound_clone(:intersect, dataset, opts)
    382:     end

interval(column) click to toggle source

Returns the interval between minimum and maximum values for the given column.

      DB[:table].interval(:id) # SELECT (max(id) - min(id)) FROM table LIMIT 1
      # => 6

         # File lib/sequel/dataset/actions.rb, line 331
    331:     def interval(column)
    332:       aggregate_dataset.get{max(column) - min(column)}
    333:     end

invert() click to toggle source

Inverts the current filter.

      DB[:items].filter(:category => 'software').invert
      # SELECT * FROM items WHERE (category != 'software')

      DB[:items].filter(:category => 'software', :id=>3).invert
      # SELECT * FROM items WHERE ((category != 'software') OR (id != 3))

         # File lib/sequel/dataset/query.rb, line 391
    391:     def invert
    392:       having, where = @opts[:having], @opts[:where]
    393:       raise(Error, "No current filter") unless having || where
    394:       o = {}
    395:       o[:having] = SQL::BooleanExpression.invert(having) if having
    396:       o[:where] = SQL::BooleanExpression.invert(where) if where
    397:       clone(o)
    398:     end

join(*args, &block) click to toggle source

Alias of `inner_join`

         # File lib/sequel/dataset/query.rb, line 401
    401:     def join(*args, &block)
    402:       inner_join(*args, &block)
    403:     end

join_clause_sql_append(sql, jc) click to toggle source

SQL fragment specifying a JOIN clause without ON or USING.

         # File lib/sequel/dataset/sql.rb, line 507
    507:     def join_clause_sql_append(sql, jc)
    508:       table = jc.table
    509:       table_alias = jc.table_alias
    510:       table_alias = nil if table == table_alias
    511:       sql << SPACE << join_type_sql(jc.join_type) << SPACE
    512:       table_ref_append(sql, table)
    513:       as_sql_append(sql, table_alias) if table_alias
    514:     end

join_on_clause_sql_append(sql, jc) click to toggle source

SQL fragment specifying a JOIN clause with ON.

         # File lib/sequel/dataset/sql.rb, line 517
    517:     def join_on_clause_sql_append(sql, jc)
    518:       join_clause_sql_append(sql, jc)
    519:       sql << ON
    520:       literal_append(sql, filter_expr(jc.on))
    521:     end

join_table(type, table, expr=nil, options={}, &block) click to toggle source

Returns a joined dataset. Not usually called directly, users should use the appropriate join method (e.g. join, left_join, natural_join, cross_join) which fills in the `type` argument.

Takes the following arguments:

- type - The type of join to do (e.g. :inner)

- table - Depends on type:

  - Dataset - a subselect is performed with an alias of tN for some value of N

  - Model (or anything responding to :table_name) - table.table_name

  - String, Symbol: table

- expr - specifies conditions, depends on type:

  - Hash, Array of two element arrays - Assumes key (1st arg) is column of joined table (unless already qualified), and value (2nd arg) is column of the last joined or primary table (or the :implicit_qualifier option). To specify multiple conditions on a single joined table column, you must use an array. Uses a JOIN with an ON clause.

  - Array - If all members of the array are symbols, considers them as columns and uses a JOIN with a USING clause. Most databases will remove duplicate columns from the result set if this is used.

  - nil - If a block is not given, doesn’t use ON or USING, so the JOIN should be a NATURAL or CROSS join. If a block is given, uses an ON clause based on the block, see below.

  - Everything else - pretty much the same as a using the argument in a call to filter, so strings are considered literal, symbols specify boolean columns, and Sequel expressions can be used. Uses a JOIN with an ON clause.

- options - a hash of options, with any of the following keys:

  - :table_alias - the name of the table’s alias when joining, necessary for joining to the same table more than once. No alias is used by default.

  - :implicit_qualifier - The name to use for qualifying implicit conditions. By default, the last joined or primary table is used.

- block - The block argument should only be given if a JOIN with an ON clause is used, in which case it yields the table alias/name for the table currently being joined, the table alias/name for the last joined (or first table), and an array of previous SQL::JoinClause. Unlike `filter`, this block is not treated as a virtual row block.

Examples:

      DB[:a].join_table(:cross, :b)
      # SELECT * FROM a CROSS JOIN b

      DB[:a].join_table(:inner, DB[:b], :c=>d)
      # SELECT * FROM a INNER JOIN (SELECT * FROM b) AS t1 ON (t1.c = a.d)

      DB[:a].join_table(:left, :b___c, [:d])
      # SELECT * FROM a LEFT JOIN b AS c USING (d)

      DB[:a].natural_join(:b).join_table(:inner, :c) do |ta, jta, js|
        (:d.qualify(ta) > :e.qualify(jta)) & {:f.qualify(ta)=>DB.from(js.first.table).select(:g)}
      end
      # SELECT * FROM a NATURAL JOIN b INNER JOIN c
      #   ON ((c.d > b.e) AND (c.f IN (SELECT g FROM b)))

         # File lib/sequel/dataset/query.rb, line 456
    456:     def join_table(type, table, expr=nil, options={}, &block)
    457:       if hoist_cte?(table)
    458:         s, ds = hoist_cte(table)
    459:         return s.join_table(type, ds, expr, options, &block)
    460:       end
    461:
    462:       using_join = expr.is_a?(Array) && !expr.empty? && expr.all?{|x| x.is_a?(Symbol)}
    463:       if using_join && !supports_join_using?
    464:         h = {}
    465:         expr.each{|s| h[s] = s}
    466:         return join_table(type, table, h, options)
    467:       end
    468:
    469:       case options
    470:       when Hash
    471:         table_alias = options[:table_alias]
    472:         last_alias = options[:implicit_qualifier]
    473:       when Symbol, String, SQL::Identifier
    474:         table_alias = options
    475:         last_alias = nil
    476:       else
    477:         raise Error, "invalid options format for join_table: #{options.inspect}"
    478:       end
    479:
    480:       if Dataset === table
    481:         if table_alias.nil?
    482:           table_alias_num = (@opts[:num_dataset_sources] || 0) + 1
    483:           table_alias = dataset_alias(table_alias_num)
    484:         end
    485:         table_name = table_alias
    486:       else
    487:         table = table.table_name if table.respond_to?(:table_name)
    488:         table, implicit_table_alias = split_alias(table)
    489:         table_alias ||= implicit_table_alias
    490:         table_name = table_alias || table
    491:       end
    492:
    493:       join = if expr.nil? and !block
    494:         SQL::JoinClause.new(type, table, table_alias)
    495:       elsif using_join
    496:         raise(Sequel::Error, "can't use a block if providing an array of symbols as expr") if block
    497:         SQL::JoinUsingClause.new(expr, type, table, table_alias)
    498:       else
    499:         last_alias ||= @opts[:last_joined_table] || first_source_alias
    500:         if Sequel.condition_specifier?(expr)
    501:           expr = expr.collect do |k, v|
    502:             k = qualified_column_name(k, table_name) if k.is_a?(Symbol)
    503:             v = qualified_column_name(v, last_alias) if v.is_a?(Symbol)
    504:             [k,v]
    505:           end
    506:           expr = SQL::BooleanExpression.from_value_pairs(expr)
    507:         end
    508:         if block
    509:           expr2 = yield(table_name, last_alias, @opts[:join] || [])
    510:           expr = expr ? SQL::BooleanExpression.new(:AND, expr, expr2) : expr2
    511:         end
    512:         SQL::JoinOnClause.new(expr, type, table, table_alias)
    513:       end
    514:
    515:       opts = {:join => (@opts[:join] || []) + [join], :last_joined_table => table_name}
    516:       opts[:num_dataset_sources] = table_alias_num if table_alias_num
    517:       clone(opts)
    518:     end

join_using_clause_sql_append(sql, jc) click to toggle source

SQL fragment specifying a JOIN clause with USING.

         # File lib/sequel/dataset/sql.rb, line 524
    524:     def join_using_clause_sql_append(sql, jc)
    525:       join_clause_sql_append(sql, jc)
    526:       sql << USING
    527:       column_list_append(sql, jc.using)
    528:       sql << PAREN_CLOSE
    529:     end

last(*args, &block) click to toggle source

Reverses the order and then runs # with the given arguments and block. Note that this will not necessarily give you the last record in the dataset, unless you have an unambiguous order. If there is not currently an order for this dataset, raises an `Error`.

      DB[:table].order(:id).last # SELECT * FROM table ORDER BY id DESC LIMIT 1
      # => {:id=>10}

      DB[:table].order(:id.desc).last(2) # SELECT * FROM table ORDER BY id ASC LIMIT 2
      # => [{:id=>1}, {:id=>2}]

         # File lib/sequel/dataset/actions.rb, line 345
    345:     def last(*args, &block)
    346:       raise(Error, 'No order specified') unless @opts[:order]
    347:       reverse.first(*args, &block)
    348:     end

limit(l, o = nil) click to toggle source

If given an integer, the dataset will contain only the first l results. If given a range, it will contain only those at offsets within that range. If a second argument is given, it is used as an offset. To use an offset without a limit, pass nil as the first argument.

      DB[:items].limit(10) # SELECT * FROM items LIMIT 10
      DB[:items].limit(10, 20) # SELECT * FROM items LIMIT 10 OFFSET 20
      DB[:items].limit(10...20) # SELECT * FROM items LIMIT 10 OFFSET 10
      DB[:items].limit(10..20) # SELECT * FROM items LIMIT 11 OFFSET 10
      DB[:items].limit(nil, 20) # SELECT * FROM items OFFSET 20

         # File lib/sequel/dataset/query.rb, line 537
    537:     def limit(l, o = nil)
    538:       return from_self.limit(l, o) if @opts[:sql]
    539:
    540:       if Range === l
    541:         o = l.first
    542:         l = l.last - l.first + (l.exclude_end? ? 0 : 1)
    543:       end
    544:       l = l.to_i if l.is_a?(String) && !l.is_a?(LiteralString)
    545:       if l.is_a?(Integer)
    546:         raise(Error, 'Limits must be greater than or equal to 1') unless l >= 1
    547:       end
    548:       opts = {:limit => l}
    549:       if o
    550:         o = o.to_i if o.is_a?(String) && !o.is_a?(LiteralString)
    551:         if o.is_a?(Integer)
    552:           raise(Error, 'Offsets must be greater than or equal to 0') unless o >= 0
    553:         end
    554:         opts[:offset] = o
    555:       end
    556:       clone(opts)
    557:     end

literal_append(sql, v) click to toggle source

Returns a literal representation of a value to be used as part of an SQL expression.

      DB[:items].literal("abc'def\\") #=> "'abc''def\\\\'"
      DB[:items].literal(:items__id) #=> "items.id"
      DB[:items].literal([1, 2, 3]) => "(1, 2, 3)"
      DB[:items].literal(DB[:items]) => "(SELECT * FROM items)"
      DB[:items].literal(:x + 1 > :y) => "((x + 1) > y)"

If an unsupported object is given, an `Error` is raised.

         # File lib/sequel/dataset/sql.rb, line 81
     81:     def literal_append(sql, v)
     82:       case v
     83:       when Symbol
     84:         literal_symbol_append(sql, v)
     85:       when String
     86:         case v
     87:         when LiteralString
     88:           sql << v
     89:         when SQL::Blob
     90:           literal_blob_append(sql, v)
     91:         else
     92:           literal_string_append(sql, v)
     93:         end
     94:       when Integer
     95:         sql << literal_integer(v)
     96:       when Hash
     97:         literal_hash_append(sql, v)
     98:       when SQL::Expression
     99:         literal_expression_append(sql, v)
    100:       when Float
    101:         sql << literal_float(v)
    102:       when BigDecimal
    103:         sql << literal_big_decimal(v)
    104:       when NilClass
    105:         sql << literal_nil
    106:       when TrueClass
    107:         sql << literal_true
    108:       when FalseClass
    109:         sql << literal_false
    110:       when Array
    111:         literal_array_append(sql, v)
    112:       when Time
    113:         sql << (v.is_a?(SQLTime) ? literal_sqltime(v) : literal_time(v))
    114:       when DateTime
    115:         sql << literal_datetime(v)
    116:       when Date
    117:         sql << literal_date(v)
    118:       when Dataset
    119:         literal_dataset_append(sql, v)
    120:       else
    121:         literal_other_append(sql, v)
    122:       end
    123:     end

lock_style(style) click to toggle source

Returns a cloned dataset with the given lock style. If style is a string, it will be used directly. Otherwise, a symbol may be used for database independent locking. Currently :update is respected by most databases, and :share is supported by some.

      DB[:items].lock_style('FOR SHARE') # SELECT * FROM items FOR SHARE

         # File lib/sequel/dataset/query.rb, line 565
    565:     def lock_style(style)
    566:       clone(:lock => style)
    567:     end

map(column=nil, &block) click to toggle source

Maps column values for each record in the dataset (if a column name is given), or performs the stock mapping functionality of `Enumerable` otherwise. Raises an `Error` if both an argument and block are given.

      DB[:table].map(:id) # SELECT * FROM table
      # => [1, 2, 3, ...]

      DB[:table].map{|r| r[:id] * 2} # SELECT * FROM table
      # => [2, 4, 6, ...]

You can also provide an array of column names:

      DB[:table].map([:id, :name]) # SELECT * FROM table
      # => [[1, 'A'], [2, 'B'], [3, 'C'], ...]

         # File lib/sequel/dataset/actions.rb, line 364
    364:     def map(column=nil, &block)
    365:       if column
    366:         raise(Error, ARG_BLOCK_ERROR_MSG) if block
    367:         return naked.map(column) if row_proc
    368:         if column.is_a?(Array)
    369:           super(){|r| r.values_at(*column)}
    370:         else
    371:           super(){|r| r[column]}
    372:         end
    373:       else
    374:         super(&block)
    375:       end
    376:     end

max(column) click to toggle source

Returns the maximum value for the given column.

      DB[:table].max(:id) # SELECT max(id) FROM table LIMIT 1
      # => 10

         # File lib/sequel/dataset/actions.rb, line 382
    382:     def max(column)
    383:       aggregate_dataset.get{max(column)}
    384:     end

min(column) click to toggle source

Returns the minimum value for the given column.

      DB[:table].min(:id) # SELECT min(id) FROM table LIMIT 1
      # => 1

         # File lib/sequel/dataset/actions.rb, line 390
    390:     def min(column)
    391:       aggregate_dataset.get{min(column)}
    392:     end

multi_insert(hashes, opts={}) click to toggle source

This is a front end for import that allows you to submit an array of hashes instead of arrays of columns and values:

      DB[:table].multi_insert([{:x => 1}, {:x => 2}])
      # INSERT INTO table (x) VALUES (1)
      # INSERT INTO table (x) VALUES (2)

Be aware that all hashes should have the same keys if you use this calling method, otherwise some columns could be missed or set to null instead of to default values.

This respects the same options as #.

         # File lib/sequel/dataset/actions.rb, line 406
    406:     def multi_insert(hashes, opts={})
    407:       return if hashes.empty?
    408:       columns = hashes.first.keys
    409:       import(columns, hashes.map{|h| columns.map{|c| h[c]}}, opts)
    410:     end

multi_insert_sql(columns, values) click to toggle source

Returns an array of insert statements for inserting multiple records. This method is used by `multi_insert` to format insert statements and expects a keys array and and an array of value arrays.

This method should be overridden by descendants if the support inserting multiple records in a single SQL statement.

         # File lib/sequel/dataset/sql.rb, line 131
    131:     def multi_insert_sql(columns, values)
    132:       values.map{|r| insert_sql(columns, r)}
    133:     end

naked() click to toggle source

Returns a cloned dataset without a row_proc.

      ds = DB[:items]
      ds.row_proc = proc{|r| r.invert}
      ds.all # => [{2=>:id}]
      ds.naked.all # => [{:id=>2}]

         # File lib/sequel/dataset/query.rb, line 575
    575:     def naked
    576:       ds = clone
    577:       ds.row_proc = nil
    578:       ds
    579:     end

naked!() click to toggle source

Remove the row_proc from the current dataset.

        # File lib/sequel/dataset/mutation.rb, line 44
    44:     def naked!
    45:       self.row_proc = nil
    46:       self
    47:     end

negative_boolean_constant_sql_append(sql, constant) click to toggle source

SQL fragment for NegativeBooleanConstants

         # File lib/sequel/dataset/sql.rb, line 532
    532:     def negative_boolean_constant_sql_append(sql, constant)
    533:       sql << NOT_SPACE
    534:       boolean_constant_sql_append(sql, constant)
    535:     end

or(*cond, &block) click to toggle source

Adds an alternate filter to an existing filter using OR. If no filter exists an `Error` is raised.

      DB[:items].filter(:a).or(:b) # SELECT * FROM items WHERE a OR b

         # File lib/sequel/dataset/query.rb, line 585
    585:     def or(*cond, &block)
    586:       clause = (@opts[:having] ? :having : :where)
    587:       raise(InvalidOperation, "No existing filter found.") unless @opts[clause]
    588:       cond = cond.first if cond.size == 1
    589:       clone(clause => SQL::BooleanExpression.new(:OR, @opts[clause], filter_expr(cond, &block)))
    590:     end

order(*columns, &block) click to toggle source

Returns a copy of the dataset with the order changed. If the dataset has an existing order, it is ignored and overwritten with this order. If a nil is given the returned dataset has no order. This can accept multiple arguments of varying kinds, such as SQL functions. If a block is given, it is treated as a virtual row block, similar to `filter`.

      DB[:items].order(:name) # SELECT * FROM items ORDER BY name
      DB[:items].order(:a, :b) # SELECT * FROM items ORDER BY a, b
      DB[:items].order('a + b'.lit) # SELECT * FROM items ORDER BY a + b
      DB[:items].order(:a + :b) # SELECT * FROM items ORDER BY (a + b)
      DB[:items].order(:name.desc) # SELECT * FROM items ORDER BY name DESC
      DB[:items].order(:name.asc(:nulls=>:last)) # SELECT * FROM items ORDER BY name ASC NULLS LAST
      DB[:items].order{sum(name).desc} # SELECT * FROM items ORDER BY sum(name) DESC
      DB[:items].order(nil) # SELECT * FROM items

         # File lib/sequel/dataset/query.rb, line 606
    606:     def order(*columns, &block)
    607:       virtual_row_columns(columns, block)
    608:       clone(:order => (columns.compact.empty?) ? nil : columns)
    609:     end

order_append(*columns, &block) click to toggle source

Alias of order_more, for naming consistency with order_prepend.

         # File lib/sequel/dataset/query.rb, line 612
    612:     def order_append(*columns, &block)
    613:       order_more(*columns, &block)
    614:     end

order_by(*columns, &block) click to toggle source

Alias of order

         # File lib/sequel/dataset/query.rb, line 617
    617:     def order_by(*columns, &block)
    618:       order(*columns, &block)
    619:     end

order_more(*columns, &block) click to toggle source

Returns a copy of the dataset with the order columns added to the end of the existing order.

      DB[:items].order(:a).order(:b) # SELECT * FROM items ORDER BY b
      DB[:items].order(:a).order_more(:b) # SELECT * FROM items ORDER BY a, b

         # File lib/sequel/dataset/query.rb, line 626
    626:     def order_more(*columns, &block)
    627:       columns = @opts[:order] + columns if @opts[:order]
    628:       order(*columns, &block)
    629:     end

order_prepend(*columns, &block) click to toggle source

Returns a copy of the dataset with the order columns added to the beginning of the existing order.

      DB[:items].order(:a).order(:b) # SELECT * FROM items ORDER BY b
      DB[:items].order(:a).order_prepend(:b) # SELECT * FROM items ORDER BY b, a

         # File lib/sequel/dataset/query.rb, line 636
    636:     def order_prepend(*columns, &block)
    637:       ds = order(*columns, &block)
    638:       @opts[:order] ? ds.order_more(*@opts[:order]) : ds
    639:     end

ordered_expression_sql_append(sql, oe) click to toggle source

SQL fragment for the ordered expression, used in the ORDER BY clause.

         # File lib/sequel/dataset/sql.rb, line 539
    539:     def ordered_expression_sql_append(sql, oe)
    540:       literal_append(sql, oe.expression)
    541:       sql << (oe.descending ? DESC : ASC)
    542:       case oe.nulls
    543:       when :first
    544:         sql << NULLS_FIRST
    545:       when :last
    546:         sql << NULLS_LAST
    547:       end
    548:     end

paginate(page_no, page_size, record_count=nil) click to toggle source

Returns a paginated dataset. The returned dataset is limited to the page size at the correct offset, and extended with the Pagination module. If a record count is not provided, does a count of total number of records for this dataset.

        # File lib/sequel/extensions/pagination.rb, line 11
    11:     def paginate(page_no, page_size, record_count=nil)
    12:       raise(Error, "You cannot paginate a dataset that already has a limit") if @opts[:limit]
    13:       paginated = limit(page_size, (page_no - 1) * page_size)
    14:       paginated.extend(Pagination)
    15:       paginated.set_pagination_info(page_no, page_size, record_count || count)
    16:     end

placeholder_literal_string_sql_append(sql, pls) click to toggle source

SQL fragment for a literal string with placeholders

         # File lib/sequel/dataset/sql.rb, line 551
    551:     def placeholder_literal_string_sql_append(sql, pls)
    552:       args = pls.args
    553:       sql << PAREN_OPEN if pls.parens
    554:       if args.is_a?(Hash)
    555:         re = /:(#{args.keys.map{|k| Regexp.escape(k.to_s)}.join('|')})\b/
    556:         if RUBY_VERSION >= '1.8.7'
    557:           str = pls.str
    558:           loop do
    559:             previous, q, str = str.partition(re)
    560:             sql << previous
    561:             literal_append(sql, args[($1||q[1..1].to_s).to_sym]) unless q.empty?
    562:             break if str.empty?
    563:           end
    564:         else
    565:           sql << pls.str.gsub(re){literal(args[$1.to_sym])}
    566:         end
    567:       else
    568:         i = 1
    569:         if RUBY_VERSION >= '1.8.7'
    570:           str = pls.str
    571:           loop do
    572:             previous, q, str = str.partition(QUESTION_MARK)
    573:             sql << previous
    574:             literal_append(sql, args.at(i+=1)) unless q.empty?
    575:             break if str.empty?
    576:           end
    577:         else
    578:           sql << pls.str.gsub(QUESTION_MARK_RE){literal(args.at(i+=1))}
    579:         end
    580:       end
    581:       sql << PAREN_CLOSE if pls.parens
    582:     end

prepare(type, name=nil, *values) click to toggle source

Prepare the given type of query with the given name and store it in the database. Note that a new native prepared statement is created on each call to this prepared statement.

         # File lib/sequel/adapters/oracle.rb, line 370
    370:       def prepare(type, name=nil, *values)
    371:         ps = to_prepared_statement(type, values)
    372:         ps.extend(PreparedStatementMethods)
    373:         if name
    374:           ps.prepared_statement_name = name
    375:           db.prepared_statements[name] = ps
    376:         end
    377:         ps
    378:       end

prepare(type, name=nil, *values) click to toggle source

Prepare an SQL statement for later execution. Takes a type similar to #, and the `name` symbol of the prepared statement. While `name` defaults to `nil`, it should always be provided as a symbol for the name of the prepared statement, as some databases require that prepared statements have names.

This returns a clone of the dataset extended with PreparedStatementMethods, which you can `call` with the hash of bind variables to use. The prepared statement is also stored in the associated database, where it can be called by name. The following usage is identical:

      ps = DB[:table].filter(:name=>:$name).prepare(:first, :select_by_name)

      ps.call(:name=>'Blah')
      # SELECT * FROM table WHERE name = ? -- ('Blah')
      # => {:id=>1, :name=>'Blah'}

      DB.call(:select_by_name, :name=>'Blah') # Same thing

         # File lib/sequel/dataset/prepared_statements.rb, line 244
    244:     def prepare(type, name=nil, *values)
    245:       ps = to_prepared_statement(type, values)
    246:       db.prepared_statements[name] = ps if name
    247:       ps
    248:     end

prepare(type, name=nil, *values) click to toggle source

Prepare the given type of statement with the given name, and store it in the database to be called later.

         # File lib/sequel/adapters/postgres.rb, line 611
    611:         def prepare(type, name=nil, *values)
    612:           ps = to_prepared_statement(type, values)
    613:           ps.extend(PreparedStatementMethods)
    614:           if name
    615:             ps.prepared_statement_name = name
    616:             db.prepared_statements[name] = ps
    617:           end
    618:           ps
    619:         end

prepare(type, name=nil, *values) click to toggle source

Create a named prepared statement that is stored in the database (and connection) for reuse.

         # File lib/sequel/adapters/jdbc.rb, line 601
    601:       def prepare(type, name=nil, *values)
    602:         ps = to_prepared_statement(type, values)
    603:         ps.extend(PreparedStatementMethods)
    604:         if name
    605:           ps.prepared_statement_name = name
    606:           db.prepared_statements[name] = ps
    607:         end
    608:         ps
    609:       end

prepare(type, name=nil, *values) click to toggle source

Create a named prepared statement that is stored in the database (and connection) for reuse.

         # File lib/sequel/adapters/oracle.rb, line 402
    402:       def prepare(type, name=nil, *values)
    403:         ps = to_prepared_statement(type, values)
    404:         ps.extend(PreparedStatementMethods)
    405:         if name
    406:           ps.prepared_statement_name = name
    407:           db.prepared_statements[name] = ps
    408:         end
    409:         ps
    410:       end

prepared_arg_placeholder() click to toggle source

PostgreSQL uses $N for placeholders instead of ?, so use a $ as the placeholder.

         # File lib/sequel/adapters/postgres.rb, line 625
    625:         def prepared_arg_placeholder
    626:           PREPARED_ARG_PLACEHOLDER
    627:         end

print(*cols) click to toggle source

Pretty prints the records in the dataset as plain-text table.

        # File lib/sequel/extensions/pretty_table.rb, line 8
     8:     def print(*cols)
     9:       Sequel::PrettyTable.print(naked.all, cols.empty? ? columns : cols)
    10:     end

provides_accurate_rows_matched?() click to toggle source

You can parse out the correct number of rows matched using the query info, even though affected_rows doesn’t provide an accurate number.

         # File lib/sequel/adapters/mysql.rb, line 320
    320:       def provides_accurate_rows_matched?
    321:         true
    322:       end

provides_accurate_rows_matched?() click to toggle source

Whether this dataset will provide accurate number of rows matched for delete and update statements. Accurate in this case is the number of rows matched by the dataset’s filter.

        # File lib/sequel/dataset/features.rb, line 23
    23:     def provides_accurate_rows_matched?
    24:       true
    25:     end

qualified_identifier_sql_append(sql, qcr) click to toggle source

SQL fragment for the qualifed identifier, specifying a table and a column (or schema and table).

         # File lib/sequel/dataset/sql.rb, line 586
    586:     def qualified_identifier_sql_append(sql, qcr)
    587:       case t = qcr.table
    588:       when Symbol, SQL::QualifiedIdentifier, SQL::Identifier
    589:         literal_append(sql, t)
    590:       else
    591:         quote_identifier_append(sql, t)
    592:       end
    593:       sql << DOT
    594:       case c = qcr.column
    595:       when Symbol, SQL::QualifiedIdentifier, SQL::Identifier
    596:         literal_append(sql, c)
    597:       else
    598:         quote_identifier_append(sql, c)
    599:       end
    600:     end

qualify(table=first_source) click to toggle source

Qualify to the given table, or first source if no table is given.

      DB[:items].filter(:id=>1).qualify
      # SELECT items.* FROM items WHERE (items.id = 1)

      DB[:items].filter(:id=>1).qualify(:i)
      # SELECT i.* FROM items WHERE (i.id = 1)

         # File lib/sequel/dataset/query.rb, line 648
    648:     def qualify(table=first_source)
    649:       qualify_to(table)
    650:     end

qualify_to(table) click to toggle source

Return a copy of the dataset with unqualified identifiers in the SELECT, WHERE, GROUP, HAVING, and ORDER clauses qualified by the given table. If no columns are currently selected, select all columns of the given table.

      DB[:items].filter(:id=>1).qualify_to(:i)
      # SELECT i.* FROM items WHERE (i.id = 1)

         # File lib/sequel/dataset/query.rb, line 659
    659:     def qualify_to(table)
    660:       o = @opts
    661:       return clone if o[:sql]
    662:       h = {}
    663:       (o.keys & QUALIFY_KEYS).each do |k|
    664:         h[k] = qualified_expression(o[k], table)
    665:       end
    666:       h[:select] = [SQL::ColumnAll.new(table)] if !o[:select] || o[:select].empty?
    667:       clone(h)
    668:     end

qualify_to_first_source() click to toggle source

Qualify the dataset to its current first source. This is useful if you have unqualified identifiers in the query that all refer to the first source, and you want to join to another table which has columns with the same name as columns in the current dataset. See `qualify_to`.

      DB[:items].filter(:id=>1).qualify_to_first_source
      # SELECT items.* FROM items WHERE (items.id = 1)

         # File lib/sequel/dataset/query.rb, line 678
    678:     def qualify_to_first_source
    679:       qualify_to(first_source)
    680:     end

query(&block) click to toggle source

Translates a query block into a dataset. Query blocks can be useful when expressing complex SELECT statements, e.g.:

      dataset = DB[:items].query do
        select :x, :y, :z
        filter{|o| (o.x > 1) & (o.y > 2)}
        order :z.desc
      end

Which is the same as:

     dataset = DB[:items].select(:x, :y, :z).filter{|o| (o.x > 1) & (o.y > 2)}.order(:z.desc)

Note that inside a call to query, you cannot call each, insert, update, or delete (or any method that calls those), or Sequel will raise an error.

        # File lib/sequel/extensions/query.rb, line 30
    30:     def query(&block)
    31:       copy = clone({})
    32:       copy.extend(QueryBlockCopy)
    33:       copy.instance_eval(&block)
    34:       clone(copy.opts)
    35:     end

quote_identifier_append(sql, name) click to toggle source

Adds quoting to identifiers (columns and tables). If identifiers are not being quoted, returns name as a string. If identifiers are being quoted quote the name with quoted_identifier.

         # File lib/sequel/dataset/sql.rb, line 605
    605:     def quote_identifier_append(sql, name)
    606:       if name.is_a?(LiteralString)
    607:         sql << name
    608:       else
    609:         name = name.value if name.is_a?(SQL::Identifier)
    610:         name = input_identifier(name)
    611:         if quote_identifiers?
    612:           quoted_identifier_append(sql, name)
    613:         else
    614:           sql << name
    615:         end
    616:       end
    617:     end

quote_identifiers?() click to toggle source

Whether this dataset quotes identifiers.

        # File lib/sequel/dataset/features.rb, line 10
    10:     def quote_identifiers?
    11:       if defined?(@quote_identifiers)
    12:         @quote_identifiers
    13:       elsif db.respond_to?(:quote_identifiers?)
    14:         @quote_identifiers = db.quote_identifiers?
    15:       else
    16:         @quote_identifiers = false
    17:       end
    18:     end

quote_schema_table_append(sql, table) click to toggle source

Separates the schema from the table and returns a string with them quoted (if quoting identifiers)

         # File lib/sequel/dataset/sql.rb, line 621
    621:     def quote_schema_table_append(sql, table)
    622:       schema, table = schema_and_table(table)
    623:       if schema
    624:         quote_identifier_append(sql, schema)
    625:         sql << DOT
    626:       end
    627:       quote_identifier_append(sql, table)
    628:     end

quoted_identifier_append(sql, name) click to toggle source

This method quotes the given name with the SQL standard double quote. should be overridden by subclasses to provide quoting not matching the SQL standard, such as backtick (used by MySQL and SQLite).

         # File lib/sequel/dataset/sql.rb, line 633
    633:     def quoted_identifier_append(sql, name)
    634:       sql << QUOTE << name.to_s.gsub(QUOTE_RE, DOUBLE_QUOTE) << QUOTE
    635:     end

range(column) click to toggle source

Returns a `Range` instance made from the minimum and maximum values for the given column.

      DB[:table].range(:id) # SELECT max(id) AS v1, min(id) AS v2 FROM table LIMIT 1
      # => 1..10

         # File lib/sequel/dataset/actions.rb, line 417
    417:     def range(column)
    418:       if r = aggregate_dataset.select{[min(column).as(v1), max(column).as(v2)]}.first
    419:         (r[:v1]..r[:v2])
    420:       end
    421:     end

recursive_cte_requires_column_aliases?() click to toggle source

Whether you must use a column alias list for recursive CTEs (false by default).

        # File lib/sequel/dataset/features.rb, line 29
    29:     def recursive_cte_requires_column_aliases?
    30:       false
    31:     end

replace(*args) click to toggle source

Replace (update or insert) the matching row.

         # File lib/sequel/adapters/mysql.rb, line 325
    325:       def replace(*args)
    326:         execute_dui(replace_sql(*args)){|c| return c.insert_id}
    327:       end

requires_placeholder_type_specifiers?() click to toggle source

Whether type specifiers are required for prepared statement/bound variable argument placeholders (i.e. :bv__integer)

        # File lib/sequel/dataset/features.rb, line 41
    41:     def requires_placeholder_type_specifiers?
    42:       false
    43:     end

requires_placeholder_type_specifiers?() click to toggle source

Oracle requires type specifiers for placeholders, at least if you ever want to use a nil/NULL value as the value for the placeholder.

         # File lib/sequel/adapters/oracle.rb, line 415
    415:       def requires_placeholder_type_specifiers?
    416:         true
    417:       end

requires_sql_standard_datetimes?() click to toggle source

Whether the dataset requires SQL standard datetimes (false by default, as most allow strings with ISO 8601 format).

        # File lib/sequel/dataset/features.rb, line 35
    35:     def requires_sql_standard_datetimes?
    36:       false
    37:     end

returning(*values) click to toggle source

Modify the RETURNING clause, only supported on a few databases. If returning is used, instead of insert returning the autogenerated primary key or update/delete returning the number of modified rows, results are returned using `fetch_rows`.

      DB[:items].returning # RETURNING *
      DB[:items].returning(nil) # RETURNING NULL
      DB[:items].returning(:id, :name) # RETURNING id, name

         # File lib/sequel/dataset/query.rb, line 690
    690:     def returning(*values)
    691:       clone(:returning=>values)
    692:     end

reverse(*order) click to toggle source

Returns a copy of the dataset with the order reversed. If no order is given, the existing order is inverted.

      DB[:items].reverse(:id) # SELECT * FROM items ORDER BY id DESC
      DB[:items].order(:id).reverse # SELECT * FROM items ORDER BY id DESC
      DB[:items].order(:id).reverse(:name.asc) # SELECT * FROM items ORDER BY name ASC

         # File lib/sequel/dataset/query.rb, line 700
    700:     def reverse(*order)
    701:       order(*invert_order(order.empty? ? @opts[:order] : order))
    702:     end

reverse_order(*order) click to toggle source

Alias of `reverse`

         # File lib/sequel/dataset/query.rb, line 705
    705:     def reverse_order(*order)
    706:       reverse(*order)
    707:     end

row_number_column() click to toggle source

The alias to use for the row_number column, used when emulating OFFSET support and for eager limit strategies

         # File lib/sequel/dataset/misc.rb, line 147
    147:     def row_number_column
    148:       :x_sequel_row_number_x
    149:     end

schema_and_table(table_name) click to toggle source

Split the schema information from the table

         # File lib/sequel/dataset/sql.rb, line 638
    638:     def schema_and_table(table_name)
    639:       sch = db.default_schema if db
    640:       case table_name
    641:       when Symbol
    642:         s, t, a = split_symbol(table_name)
    643:         [s||sch, t]
    644:       when SQL::QualifiedIdentifier
    645:         [table_name.table, table_name.column]
    646:       when SQL::Identifier
    647:         [sch, table_name.value]
    648:       when String
    649:         [sch, table_name]
    650:       else
    651:         raise Error, 'table_name should be a Symbol, SQL::QualifiedIdentifier, SQL::Identifier, or String'
    652:       end
    653:     end

select(*columns, &block) click to toggle source

Returns a copy of the dataset with the columns selected changed to the given columns. This also takes a virtual row block, similar to `filter`.

      DB[:items].select(:a) # SELECT a FROM items
      DB[:items].select(:a, :b) # SELECT a, b FROM items
      DB[:items].select{[a, sum(b)]} # SELECT a, sum(b) FROM items

         # File lib/sequel/dataset/query.rb, line 716
    716:     def select(*columns, &block)
    717:       virtual_row_columns(columns, block)
    718:       m = []
    719:       columns.each do |i|
    720:         i.is_a?(Hash) ? m.concat(i.map{|k, v| SQL::AliasedExpression.new(k,v)}) : m << i
    721:       end
    722:       clone(:select => m)
    723:     end

select_all(*tables) click to toggle source

Returns a copy of the dataset selecting the wildcard if no arguments are given. If arguments are given, treat them as tables and select all columns (using the wildcard) from each table.

      DB[:items].select(:a).select_all # SELECT * FROM items
      DB[:items].select_all(:items) # SELECT items.* FROM items
      DB[:items].select_all(:items, :foo) # SELECT items.*, foo.* FROM items

         # File lib/sequel/dataset/query.rb, line 732
    732:     def select_all(*tables)
    733:       if tables.empty?
    734:         clone(:select => nil)
    735:       else
    736:         select(*tables.map{|t| i, a = split_alias(t); a || i}.map{|t| SQL::ColumnAll.new(t)})
    737:       end
    738:     end

select_append(*columns, &block) click to toggle source

Returns a copy of the dataset with the given columns added to the existing selected columns. If no columns are currently selected, it will select the columns given in addition to *.

      DB[:items].select(:a).select(:b) # SELECT b FROM items
      DB[:items].select(:a).select_append(:b) # SELECT a, b FROM items
      DB[:items].select_append(:b) # SELECT *, b FROM items

         # File lib/sequel/dataset/query.rb, line 747
    747:     def select_append(*columns, &block)
    748:       cur_sel = @opts[:select]
    749:       if !cur_sel || cur_sel.empty?
    750:         unless supports_select_all_and_column?
    751:           return select_all(*(Array(@opts[:from]) + Array(@opts[:join]))).select_more(*columns, &block)
    752:         end
    753:         cur_sel = [WILDCARD]
    754:       end
    755:       select(*(cur_sel + columns), &block)
    756:     end

select_group(*columns, &block) click to toggle source

Set both the select and group clauses with the given `columns`. Column aliases may be supplied, and will be included in the select clause. This also takes a virtual row block similar to `filter`.

      DB[:items].select_group(:a, :b)
      # SELECT a, b FROM items GROUP BY a, b

      DB[:items].select_group(:c___a){f(c2)}
      # SELECT c AS a, f(c2) FROM items GROUP BY c, f(c2)

         # File lib/sequel/dataset/query.rb, line 767
    767:     def select_group(*columns, &block)
    768:       virtual_row_columns(columns, block)
    769:       select(*columns).group(*columns.map{|c| unaliased_identifier(c)})
    770:     end

select_hash(key_column, value_column) click to toggle source

Returns a hash with key_column values as keys and value_column values as values. Similar to to_hash, but only selects the two columns.

      DB[:table].select_hash(:id, :name) # SELECT id, name FROM table
      # => {1=>'a', 2=>'b', ...}

You can also provide an array of column names for either the key_column, the value column, or both:

      DB[:table].select_hash([:id, :foo], [:name, :bar]) # SELECT * FROM table
      # {[1, 3]=>['a', 'c'], [2, 4]=>['b', 'd'], ...}

When using this method, you must be sure that each expression has an alias that Sequel can determine. Usually you can do this by calling the # method on the expression and providing an alias.

         # File lib/sequel/dataset/actions.rb, line 438
    438:     def select_hash(key_column, value_column)
    439:       if key_column.is_a?(Array)
    440:         if value_column.is_a?(Array)
    441:           select(*(key_column + value_column)).to_hash(key_column.map{|c| hash_key_symbol(c)}, value_column.map{|c| hash_key_symbol(c)})
    442:         else
    443:           select(*(key_column + [value_column])).to_hash(key_column.map{|c| hash_key_symbol(c)}, hash_key_symbol(value_column))
    444:         end
    445:       elsif value_column.is_a?(Array)
    446:         select(key_column, *value_column).to_hash(hash_key_symbol(key_column), value_column.map{|c| hash_key_symbol(c)})
    447:       else
    448:         select(key_column, value_column).to_hash(hash_key_symbol(key_column), hash_key_symbol(value_column))
    449:       end
    450:     end

select_map(column=nil, &block) click to toggle source

Selects the column given (either as an argument or as a block), and returns an array of all values of that column in the dataset. If you give a block argument that returns an array with multiple entries, the contents of the resulting array are undefined. Raises an Error if called with both an argument and a block.

      DB[:table].select_map(:id) # SELECT id FROM table
      # => [3, 5, 8, 1, ...]

      DB[:table].select_map{id * 2} # SELECT (id * 2) FROM table
      # => [6, 10, 16, 2, ...]

You can also provide an array of column names:

      DB[:table].select_map([:id, :name]) # SELECT id, name FROM table
      # => [[1, 'A'], [2, 'B'], [3, 'C'], ...]

If you provide an array of expressions, you must be sure that each entry in the array has an alias that Sequel can determine. Usually you can do this by calling the # method on the expression and providing an alias.

         # File lib/sequel/dataset/actions.rb, line 472
    472:     def select_map(column=nil, &block)
    473:       _select_map(column, false, &block)
    474:     end

select_more(*columns, &block) click to toggle source

Returns a copy of the dataset with the given columns added to the existing selected columns. If no columns are currently selected it will just select the columns given.

      DB[:items].select(:a).select(:b) # SELECT b FROM items
      DB[:items].select(:a).select_more(:b) # SELECT a, b FROM items
      DB[:items].select_more(:b) # SELECT b FROM items

         # File lib/sequel/dataset/query.rb, line 779
    779:     def select_more(*columns, &block)
    780:       columns = @opts[:select] + columns if @opts[:select]
    781:       select(*columns, &block)
    782:     end

select_order_map(column=nil, &block) click to toggle source

The same as select_map, but in addition orders the array by the column.

      DB[:table].select_order_map(:id) # SELECT id FROM table ORDER BY id
      # => [1, 2, 3, 4, ...]

      DB[:table].select_order_map{id * 2} # SELECT (id * 2) FROM table ORDER BY (id * 2)
      # => [2, 4, 6, 8, ...]

You can also provide an array of column names:

      DB[:table].select_order_map([:id, :name]) # SELECT id, name FROM table ORDER BY id, name
      # => [[1, 'A'], [2, 'B'], [3, 'C'], ...]

If you provide an array of expressions, you must be sure that each entry in the array has an alias that Sequel can determine. Usually you can do this by calling the # method on the expression and providing an alias.

         # File lib/sequel/dataset/actions.rb, line 493
    493:     def select_order_map(column=nil, &block)
    494:       _select_map(column, true, &block)
    495:     end

select_sql() click to toggle source

Returns a SELECT SQL query string.

      dataset.select_sql # => "SELECT * FROM items"

         # File lib/sequel/dataset/sql.rb, line 138
    138:     def select_sql
    139:       return static_sql(@opts[:sql]) if @opts[:sql]
    140:       clause_sql(:select)
    141:     end

server(servr) click to toggle source

Set the server for this dataset to use. Used to pick a specific database shard to run a query against, or to override the default (where SELECT uses :read_only database and all other queries use the :default database). This method is always available but is only useful when database sharding is being used.

      DB[:items].all # Uses the :read_only or :default server
      DB[:items].delete # Uses the :default server
      DB[:items].server(:blah).delete # Uses the :blah server

         # File lib/sequel/dataset/query.rb, line 793
    793:     def server(servr)
    794:       clone(:server=>servr)
    795:     end

set(*args) click to toggle source

Alias for update, but not aliased directly so subclasses don’t have to override both methods.

         # File lib/sequel/dataset/actions.rb, line 499
    499:     def set(*args)
    500:       update(*args)
    501:     end

set_defaults(hash) click to toggle source

Set the default values for insert and update statements. The values hash passed to insert or update are merged into this hash, so any values in the hash passed to insert or update will override values passed to this method.

      DB[:items].set_defaults(:a=>'a', :c=>'c').insert(:a=>'d', :b=>'b')
      # INSERT INTO items (a, c, b) VALUES ('d', 'c', 'b')

         # File lib/sequel/dataset/query.rb, line 803
    803:     def set_defaults(hash)
    804:       clone(:defaults=>(@opts[:defaults]||{}).merge(hash))
    805:     end

set_graph_aliases(graph_aliases) click to toggle source

This allows you to manually specify the graph aliases to use when using graph. You can use it to only select certain columns, and have those columns mapped to specific aliases in the result set. This is the equivalent of `select` for a graphed dataset, and must be used instead of `select` whenever graphing is used.

graph_aliases | Should be a hash with keys being symbols of column aliases, and values being either symbols or arrays with one to three elements. If the value is a symbol, it is assumed to be the same as a one element array containing that symbol. The first element of the array should be the table alias symbol. The second should be the actual column name symbol. If the array only has a single element the column name symbol will be assumed to be the same as the corresponding hash key. If the array has a third element, it is used as the value returned, instead of table_alias.column_name.

      DB[:artists].graph(:albums, :artist_id=>:id).
        set_graph_aliases(:name=>:artists,
                          :album_name=>[:albums, :name],
                          :forty_two=>[:albums, :fourtwo, 42]).first
      # SELECT artists.name, albums.name AS album_name, 42 AS forty_two ...
      # => {:artists=>{:name=>artists.name}, :albums=>{:name=>albums.name, :fourtwo=>42}}

         # File lib/sequel/dataset/graph.rb, line 230
    230:     def set_graph_aliases(graph_aliases)
    231:       columns, graph_aliases = graph_alias_columns(graph_aliases)
    232:       ds = select(*columns)
    233:       ds.opts[:graph_aliases] = graph_aliases
    234:       ds
    235:     end

set_overrides(hash) click to toggle source

Set values that override hash arguments given to insert and update statements. This hash is merged into the hash provided to insert or update, so values will override any values given in the insert/update hashes.

      DB[:items].set_overrides(:a=>'a', :c=>'c').insert(:a=>'d', :b=>'b')
      # INSERT INTO items (a, c, b) VALUES ('a', 'c', 'b')

         # File lib/sequel/dataset/query.rb, line 813
    813:     def set_overrides(hash)
    814:       clone(:overrides=>hash.merge(@opts[:overrides]||{}))
    815:     end

single_record() click to toggle source

Returns the first record in the dataset, or nil if the dataset has no records. Users should probably use `first` instead of this method.

         # File lib/sequel/dataset/actions.rb, line 506
    506:     def single_record
    507:       clone(:limit=>1).each{|r| return r}
    508:       nil
    509:     end

single_value() click to toggle source

Returns the first value of the first record in the dataset. Returns nil if dataset is empty. Users should generally use `get` instead of this method.

         # File lib/sequel/dataset/actions.rb, line 514
    514:     def single_value
    515:       if r = naked.ungraphed.single_record
    516:         r.values.first
    517:       end
    518:     end

split_alias(c) click to toggle source

Splits a possible implicit alias in `c`, handling both SQL::AliasedExpressions and Symbols. Returns an array of two elements, with the first being the main expression, and the second being the alias.

         # File lib/sequel/dataset/misc.rb, line 154
    154:     def split_alias(c)
    155:       case c
    156:       when Symbol
    157:         c_table, column, aliaz = split_symbol(c)
    158:         [c_table ? SQL::QualifiedIdentifier.new(c_table, column.to_sym) : column.to_sym, aliaz]
    159:       when SQL::AliasedExpression
    160:         [c.expression, c.aliaz]
    161:       when SQL::JoinClause
    162:         [c.table, c.table_alias]
    163:       else
    164:         [c, nil]
    165:       end
    166:     end

split_multiple_result_sets() click to toggle source

Makes each yield arrays of rows, with each array containing the rows for a given result set. Does not work with graphing. So you can submit SQL with multiple statements and easily determine which statement returned which results.

Modifies the row_proc of the returned dataset so that it still works as expected (running on the hashes instead of on the arrays of hashes). If you modify the row_proc afterward, note that it will receive an array of hashes instead of a hash.

         # File lib/sequel/adapters/mysql.rb, line 338
    338:       def split_multiple_result_sets
    339:         raise(Error, "Can't split multiple statements on a graphed dataset") if opts[:graph]
    340:         ds = clone(:split_multiple_result_sets=>true)
    341:         ds.row_proc = proc{|x| x.map{|h| row_proc.call(h)}} if row_proc
    342:         ds
    343:       end

sql() click to toggle source

Same as `select_sql`, not aliased directly to make subclassing simpler.

         # File lib/sequel/dataset/sql.rb, line 144
    144:     def sql
    145:       select_sql
    146:     end

subscript_sql_append(sql, s) click to toggle source

SQL fragment for specifying subscripts (SQL array accesses)

         # File lib/sequel/dataset/sql.rb, line 656
    656:     def subscript_sql_append(sql, s)
    657:       literal_append(sql, s.f)
    658:       sql << BRACKET_OPEN
    659:       expression_list_append(sql, s.sub)
    660:       sql << BRACKET_CLOSE
    661:     end

sum(column) click to toggle source

Returns the sum for the given column.

      DB[:table].sum(:id) # SELECT sum(id) FROM table LIMIT 1
      # => 55

         # File lib/sequel/dataset/actions.rb, line 524
    524:     def sum(column)
    525:       aggregate_dataset.get{sum(column)}
    526:     end

supports_cte?(type=:select) click to toggle source

Whether the dataset supports common table expressions (the WITH clause). If given, `type` can be :select, :insert, :update, or :delete, in which case it determines whether WITH is supported for the respective statement type.

        # File lib/sequel/dataset/features.rb, line 48
    48:     def supports_cte?(type=:select)
    49:       send(:"#{type}_clause_methods").include?(:"#{type}_with_sql")
    50:     end

supports_cte_in_subqueries?() click to toggle source

Whether the dataset supports common table expressions (the WITH clause) in subqueries. If false, applies the WITH clause to the main query, which can cause issues if multiple WITH clauses use the same name.

        # File lib/sequel/dataset/features.rb, line 55
    55:     def supports_cte_in_subqueries?
    56:       false
    57:     end

supports_distinct_on?() click to toggle source

Whether the dataset supports or can emulate the DISTINCT ON clause, false by default.

        # File lib/sequel/dataset/features.rb, line 60
    60:     def supports_distinct_on?
    61:       false
    62:     end

supports_group_cube?() click to toggle source

Whether the dataset supports CUBE with GROUP BY.

        # File lib/sequel/dataset/features.rb, line 65
    65:     def supports_group_cube?
    66:       false
    67:     end

supports_group_rollup?() click to toggle source

Whether the dataset supports ROLLUP with GROUP BY.

        # File lib/sequel/dataset/features.rb, line 70
    70:     def supports_group_rollup?
    71:       false
    72:     end

supports_insert_select?() click to toggle source

Whether this dataset supports the `insert_select` method for returning all columns values directly from an insert query.

        # File lib/sequel/dataset/features.rb, line 76
    76:     def supports_insert_select?
    77:       supports_returning?(:insert)
    78:     end

supports_intersect_except?() click to toggle source

Whether the dataset supports the INTERSECT and EXCEPT compound operations, true by default.

        # File lib/sequel/dataset/features.rb, line 81
    81:     def supports_intersect_except?
    82:       true
    83:     end

supports_intersect_except_all?() click to toggle source

Whether the dataset supports the INTERSECT ALL and EXCEPT ALL compound operations, true by default.

        # File lib/sequel/dataset/features.rb, line 86
    86:     def supports_intersect_except_all?
    87:       true
    88:     end

supports_is_true?() click to toggle source

Whether the dataset supports the IS TRUE syntax.

        # File lib/sequel/dataset/features.rb, line 91
    91:     def supports_is_true?
    92:       true
    93:     end

supports_join_using?() click to toggle source

Whether the dataset supports the JOIN table USING (column1, …) syntax.

        # File lib/sequel/dataset/features.rb, line 96
    96:     def supports_join_using?
    97:       true
    98:     end

supports_modifying_joins?() click to toggle source

Whether modifying joined datasets is supported.

         # File lib/sequel/dataset/features.rb, line 101
    101:     def supports_modifying_joins?
    102:       false
    103:     end

supports_multiple_column_in?() click to toggle source

Whether the IN/NOT IN operators support multiple columns when an array of values is given.

         # File lib/sequel/dataset/features.rb, line 107
    107:     def supports_multiple_column_in?
    108:       true
    109:     end

supports_ordered_distinct_on?() click to toggle source

Whether the dataset supports or can fully emulate the DISTINCT ON clause, including respecting the ORDER BY clause, false by default

         # File lib/sequel/dataset/features.rb, line 113
    113:     def supports_ordered_distinct_on?
    114:       supports_distinct_on?
    115:     end

supports_returning?(type) click to toggle source

Whether the RETURNING clause is supported for the given type of query. `type` can be :insert, :update, or :delete.

         # File lib/sequel/dataset/features.rb, line 119
    119:     def supports_returning?(type)
    120:       send(:"#{type}_clause_methods").include?(:"#{type}_returning_sql")
    121:     end

supports_select_all_and_column?() click to toggle source

Whether the database supports SELECT *, column FROM table

         # File lib/sequel/dataset/features.rb, line 124
    124:     def supports_select_all_and_column?
    125:       true
    126:     end

supports_timestamp_timezones?() click to toggle source

Whether the dataset supports timezones in literal timestamps

         # File lib/sequel/dataset/features.rb, line 129
    129:     def supports_timestamp_timezones?
    130:       false
    131:     end

supports_timestamp_usecs?() click to toggle source

Whether the dataset supports fractional seconds in literal timestamps

         # File lib/sequel/dataset/features.rb, line 134
    134:     def supports_timestamp_usecs?
    135:       true
    136:     end

supports_where_true?() click to toggle source

Whether the dataset supports WHERE TRUE (or WHERE 1 for databases that that use 1 for true).

         # File lib/sequel/dataset/features.rb, line 145
    145:     def supports_where_true?
    146:       true
    147:     end

supports_window_functions?() click to toggle source

Whether the dataset supports window functions.

         # File lib/sequel/dataset/features.rb, line 139
    139:     def supports_window_functions?
    140:       false
    141:     end

to_csv(include_column_titles = true) click to toggle source

Returns a string in CSV format containing the dataset records. By default the CSV representation includes the column titles in the first line. You can turn that off by passing false as the include_column_titles argument.

This does not use a CSV library or handle quoting of values in any way. If any values in any of the rows could include commas or line endings, you shouldn’t use this.

      puts DB[:table].to_csv # SELECT * FROM table
      # id,name
      # 1,Jim
      # 2,Bob

         # File lib/sequel/dataset/actions.rb, line 541
    541:     def to_csv(include_column_titles = true)
    542:       n = naked
    543:       cols = n.columns
    544:       csv = ''
    545:       csv << "#{cols.join(COMMA_SEPARATOR)}\r\n" if include_column_titles
    546:       n.each{|r| csv << "#{cols.collect{|c| r[c]}.join(COMMA_SEPARATOR)}\r\n"}
    547:       csv
    548:     end

to_dot() click to toggle source

Return a string that can be processed by the `dot` program (included with graphviz) in order to see a visualization of the dataset’s abstract syntax tree.

         # File lib/sequel/extensions/to_dot.rb, line 145
    145:     def to_dot
    146:       ToDot.output(self)
    147:     end

to_hash(key_column, value_column = nil) click to toggle source

Returns a hash with one column used as key and another used as value. If rows have duplicate values for the key column, the latter row(s) will overwrite the value of the previous row(s). If the value_column is not given or nil, uses the entire hash as the value.

      DB[:table].to_hash(:id, :name) # SELECT * FROM table
      # {1=>'Jim', 2=>'Bob', ...}

      DB[:table].to_hash(:id) # SELECT * FROM table
      # {1=>{:id=>1, :name=>'Jim'}, 2=>{:id=>2, :name=>'Bob'}, ...}

You can also provide an array of column names for either the key_column, the value column, or both:

      DB[:table].to_hash([:id, :foo], [:name, :bar]) # SELECT * FROM table
      # {[1, 3]=>['Jim', 'bo'], [2, 4]=>['Bob', 'be'], ...}

      DB[:table].to_hash([:id, :name]) # SELECT * FROM table
      # {[1, 'Jim']=>{:id=>1, :name=>'Jim'}, [2, 'Bob'=>{:id=>2, :name=>'Bob'}, ...}

         # File lib/sequel/dataset/actions.rb, line 569
    569:     def to_hash(key_column, value_column = nil)
    570:       h = {}
    571:       if value_column
    572:         return naked.to_hash(key_column, value_column) if row_proc
    573:         if value_column.is_a?(Array)
    574:           if key_column.is_a?(Array)
    575:             each{|r| h[r.values_at(*key_column)] = r.values_at(*value_column)}
    576:           else
    577:             each{|r| h[r[key_column]] = r.values_at(*value_column)}
    578:           end
    579:         else
    580:           if key_column.is_a?(Array)
    581:             each{|r| h[r.values_at(*key_column)] = r[value_column]}
    582:           else
    583:             each{|r| h[r[key_column]] = r[value_column]}
    584:           end
    585:         end
    586:       elsif key_column.is_a?(Array)
    587:         each{|r| h[r.values_at(*key_column)] = r}
    588:       else
    589:         each{|r| h[r[key_column]] = r}
    590:       end
    591:       h
    592:     end

truncate() click to toggle source

Truncates the dataset. Returns nil.

      DB[:table].truncate # TRUNCATE table
      # => nil

         # File lib/sequel/dataset/actions.rb, line 598
    598:     def truncate
    599:       execute_ddl(truncate_sql)
    600:     end

truncate_sql() click to toggle source

Returns a TRUNCATE SQL query string. See `truncate`

      DB[:items].truncate_sql # => 'TRUNCATE items'

         # File lib/sequel/dataset/sql.rb, line 151
    151:     def truncate_sql
    152:       if opts[:sql]
    153:         static_sql(opts[:sql])
    154:       else
    155:         check_modification_allowed!
    156:         raise(InvalidOperation, "Can't truncate filtered datasets") if opts[:where]
    157:         _truncate_sql(source_list(opts[:from]))
    158:       end
    159:     end

unbind() click to toggle source

Unbind bound variables from this dataset’s filter and return an array of two objects. The first object is a modified dataset where the filter has been replaced with one that uses bound variable placeholders. The second object is the hash of unbound variables. You can then prepare and execute (or just call) the dataset with the bound variables to get results.

      ds, bv = DB[:items].filter(:a=>1).unbind
      ds # SELECT * FROM items WHERE (a = $a)
      bv #  {:a => 1}
      ds.call(:select, bv)

         # File lib/sequel/dataset/query.rb, line 827
    827:     def unbind
    828:       u = Unbinder.new
    829:       ds = clone(:where=>u.transform(opts[:where]), :join=>u.transform(opts[:join]))
    830:       [ds, u.binds]
    831:     end

unfiltered() click to toggle source

Returns a copy of the dataset with no filters (HAVING or WHERE clause) applied.

      DB[:items].group(:a).having(:a=>1).where(:b).unfiltered
      # SELECT * FROM items GROUP BY a

         # File lib/sequel/dataset/query.rb, line 837
    837:     def unfiltered
    838:       clone(:where => nil, :having => nil)
    839:     end

ungraphed() click to toggle source

Remove the splitting of results into subhashes, and all metadata related to the current graph (if any).

         # File lib/sequel/dataset/graph.rb, line 239
    239:     def ungraphed
    240:       clone(:graph=>nil, :graph_aliases=>nil)
    241:     end

ungrouped() click to toggle source

Returns a copy of the dataset with no grouping (GROUP or HAVING clause) applied.

      DB[:items].group(:a).having(:a=>1).where(:b).ungrouped
      # SELECT * FROM items WHERE b

         # File lib/sequel/dataset/query.rb, line 845
    845:     def ungrouped
    846:       clone(:group => nil, :having => nil)
    847:     end

union(dataset, opts={}) click to toggle source

Adds a UNION clause using a second dataset object. A UNION compound dataset returns all rows in either the current dataset or the given dataset. Options:

:alias | Use the given value as the from_self alias
:all | Set to true to use UNION ALL instead of UNION, so duplicate rows can occur
:from_self | Set to false to not wrap the returned dataset in a from_self, use with care.

      DB[:items].union(DB[:other_items])
      # SELECT * FROM (SELECT * FROM items UNION SELECT * FROM other_items) AS t1

      DB[:items].union(DB[:other_items], :all=>true, :from_self=>false)
      # SELECT * FROM items UNION ALL SELECT * FROM other_items

      DB[:items].union(DB[:other_items], :alias=>:i)
      # SELECT * FROM (SELECT * FROM items UNION SELECT * FROM other_items) AS i

         # File lib/sequel/dataset/query.rb, line 865
    865:     def union(dataset, opts={})
    866:       opts = {:all=>opts} unless opts.is_a?(Hash)
    867:       compound_clone(:union, dataset, opts)
    868:     end

unlimited() click to toggle source

Returns a copy of the dataset with no limit or offset.

      DB[:items].limit(10, 20).unlimited # SELECT * FROM items

         # File lib/sequel/dataset/query.rb, line 873
    873:     def unlimited
    874:       clone(:limit=>nil, :offset=>nil)
    875:     end

unordered() click to toggle source

Returns a copy of the dataset with no order.

      DB[:items].order(:a).unordered # SELECT * FROM items

         # File lib/sequel/dataset/query.rb, line 880
    880:     def unordered
    881:       order(nil)
    882:     end

unused_table_alias(table_alias, used_aliases = []) click to toggle source

Creates a unique table alias that hasn’t already been used in the dataset. table_alias can be any type of object accepted by alias_symbol. The symbol returned will be the implicit alias in the argument, possibly appended with “_N” if the implicit alias has already been used, where N is an integer starting at 0 and increasing until an unused one is found.

You can provide a second addition array argument containing symbols that should not be considered valid table aliases. The current aliases for the FROM and JOIN tables are automatically included in this array.

      DB[:table].unused_table_alias(:t)
      # => :t

      DB[:table].unused_table_alias(:table)
      # => :table_0

      DB[:table, :table_0].unused_table_alias(:table)
      # => :table_1

      DB[:table, :table_0].unused_table_alias(:table, [:table_1, :table_2])
      # => :table_3

         # File lib/sequel/dataset/misc.rb, line 190
    190:     def unused_table_alias(table_alias, used_aliases = [])
    191:       table_alias = alias_symbol(table_alias)
    192:       used_aliases += opts[:from].map{|t| alias_symbol(t)} if opts[:from]
    193:       used_aliases += opts[:join].map{|j| j.table_alias ? alias_alias_symbol(j.table_alias) : alias_symbol(j.table)} if opts[:join]
    194:       if used_aliases.include?(table_alias)
    195:         i = 0
    196:         loop do
    197:           ta = :"#{table_alias}_#{i}"
    198:           return ta unless used_aliases.include?(ta)
    199:           i += 1
    200:         end
    201:       else
    202:         table_alias
    203:       end
    204:     end

update(values={}) click to toggle source

Update the matching rows.

         # File lib/sequel/adapters/mysql.rb, line 346
    346:       def update(values={})
    347:         execute_dui(update_sql(values)){|c| return affected_rows(c)}
    348:       end

update(values={}, &block) click to toggle source

Updates values for the dataset. The returned value is generally the number of rows updated, but that is adapter dependent. `values` should a hash where the keys are columns to set and values are the values to which to set the columns.

      DB[:table].update(:x=>nil) # UPDATE table SET x = NULL
      # => 10

      DB[:table].update(:x=>:x+1, :y=>0) # UPDATE table SET x = (x + 1), y = 0
      # => 10

         # File lib/sequel/dataset/actions.rb, line 612
    612:     def update(values={}, &block)
    613:       sql = update_sql(values)
    614:       if uses_returning?(:update)
    615:         returning_fetch_rows(sql, &block)
    616:       else
    617:         execute_dui(sql)
    618:       end
    619:     end

update_sql(values = {}) click to toggle source

Formats an UPDATE statement using the given values. See `update`.

      DB[:items].update_sql(:price => 100, :category => 'software')
      # => "UPDATE items SET price = 100, category = 'software'

Raises an `Error` if the dataset is grouped or includes more than one table.

         # File lib/sequel/dataset/sql.rb, line 168
    168:     def update_sql(values = {})
    169:       return static_sql(opts[:sql]) if opts[:sql]
    170:       check_modification_allowed!
    171:       clone(:values=>values)._update_sql
    172:     end

use_cursor(opts={}) click to toggle source

Uses a cursor for fetching records, instead of fetching the entire result set at once. Can be used to process large datasets without holding all rows in memory (which is what the underlying drivers do by default). Options:

- :rows_per_fetch - the number of rows per fetch (default 1000). Higher numbers result in fewer queries but greater memory use.

Usage:

      DB[:huge_table].use_cursor.each{|row| p row}
      DB[:huge_table].use_cursor(:rows_per_fetch=>10000).each{|row| p row}

This is untested with the prepared statement/bound variable support, and unlikely to work with either.

         # File lib/sequel/adapters/postgres.rb, line 504
    504:       def use_cursor(opts={})
    505:         clone(:cursor=>{:rows_per_fetch=>1000}.merge(opts))
    506:       end

where(*cond, &block) click to toggle source

Add a condition to the WHERE clause. See `filter` for argument types.

      DB[:items].group(:a).having(:a).filter(:b)
      # SELECT * FROM items GROUP BY a HAVING a AND b

      DB[:items].group(:a).having(:a).where(:b)
      # SELECT * FROM items WHERE b GROUP BY a HAVING a

         # File lib/sequel/dataset/query.rb, line 891
    891:     def where(*cond, &block)
    892:       _filter(:where, *cond, &block)
    893:     end

window_function_sql_append(sql, function, window) click to toggle source

The SQL fragment for the given window function’s function and window.

         # File lib/sequel/dataset/sql.rb, line 705
    705:     def window_function_sql_append(sql, function, window)
    706:       literal_append(sql, function)
    707:       sql << OVER
    708:       literal_append(sql, window)
    709:     end

window_sql_append(sql, opts) click to toggle source

The SQL fragment for the given window’s options.

         # File lib/sequel/dataset/sql.rb, line 664
    664:     def window_sql_append(sql, opts)
    665:       raise(Error, 'This dataset does not support window functions') unless supports_window_functions?
    666:       sql << PAREN_OPEN
    667:       window, part, order, frame = opts.values_at(:window, :partition, :order, :frame)
    668:       space = false
    669:       space_s = SPACE
    670:       if window
    671:         literal_append(sql, window)
    672:         space = true
    673:       end
    674:       if part
    675:         sql << space_s if space
    676:         sql << PARTITION_BY
    677:         expression_list_append(sql, Array(part))
    678:         space = true
    679:       end
    680:       if order
    681:         sql << space_s if space
    682:         sql << ORDER_BY_NS
    683:         expression_list_append(sql, Array(order))
    684:         space = true
    685:       end
    686:       case frame
    687:         when nil
    688:           # nothing
    689:         when :all
    690:           sql << space_s if space
    691:           sql << FRAME_ALL
    692:         when :rows
    693:           sql << space_s if space
    694:           sql << FRAME_ROWS
    695:         when String
    696:           sql << space_s if space
    697:           sql << frame
    698:         else
    699:           raise Error, "invalid window frame clause, should be :all, :rows, a string, or nil"
    700:       end
    701:       sql << PAREN_CLOSE
    702:     end

with(name, dataset, opts={}) click to toggle source

Add a common table expression (CTE) with the given name and a dataset that defines the CTE. A common table expression acts as an inline view for the query. Options:

:args | Specify the arguments/columns for the CTE, should be an array of symbols.
:recursive | Specify that this is a recursive CTE

      DB[:items].with(:items, DB[:syx].filter(:name.like('A%')))
      # WITH items AS (SELECT * FROM syx WHERE (name LIKE 'A%')) SELECT * FROM items

         # File lib/sequel/dataset/query.rb, line 903
    903:     def with(name, dataset, opts={})
    904:       raise(Error, 'This datatset does not support common table expressions') unless supports_cte?
    905:       if hoist_cte?(dataset)
    906:         s, ds = hoist_cte(dataset)
    907:         s.with(name, ds, opts)
    908:       else
    909:         clone(:with=>(@opts[:with]||[]) + [opts.merge(:name=>name, :dataset=>dataset)])
    910:       end
    911:     end

with_recursive(name, nonrecursive, recursive, opts={}) click to toggle source

Add a recursive common table expression (CTE) with the given name, a dataset that defines the nonrecursive part of the CTE, and a dataset that defines the recursive part of the CTE. Options:

:args | Specify the arguments/columns for the CTE, should be an array of symbols.
:union_all | Set to false to use UNION instead of UNION ALL combining the nonrecursive and recursive parts.

      DB[:t].select(:i___id, :pi___parent_id).
       with_recursive(:t,
                      DB[:i1].filter(:parent_id=>nil),
                      DB[:t].join(:t, :i=>:parent_id).select(:i1__id, :i1__parent_id),
                      :args=>[:i, :pi])
      # WITH RECURSIVE t(i, pi) AS (
      #   SELECT * FROM i1 WHERE (parent_id IS NULL)
      #   UNION ALL
      #   SELECT i1.id, i1.parent_id FROM t INNER JOIN t ON (t.i = t.parent_id)
      # )
      # SELECT i AS id, pi AS parent_id FROM t

         # File lib/sequel/dataset/query.rb, line 930
    930:     def with_recursive(name, nonrecursive, recursive, opts={})
    931:       raise(Error, 'This datatset does not support common table expressions') unless supports_cte?
    932:       if hoist_cte?(nonrecursive)
    933:         s, ds = hoist_cte(nonrecursive)
    934:         s.with_recursive(name, ds, recursive, opts)
    935:       elsif hoist_cte?(recursive)
    936:         s, ds = hoist_cte(recursive)
    937:         s.with_recursive(name, nonrecursive, ds, opts)
    938:       else
    939:         clone(:with=>(@opts[:with]||[]) + [opts.merge(:recursive=>true, :name=>name, :dataset=>nonrecursive.union(recursive, {:all=>opts[:union_all] != false, :from_self=>false}))])
    940:       end
    941:     end

with_sql(sql, *args) click to toggle source

Returns a copy of the dataset with the static SQL used. This is useful if you want to keep the same row_proc/graph, but change the SQL used to custom SQL.

      DB[:items].with_sql('SELECT * FROM foo') # SELECT * FROM foo

You can use placeholders in your SQL and provide arguments for those placeholders:

      DB[:items].with_sql('SELECT ? FROM foo', 1) # SELECT 1 FROM foo

You can also provide a method name and arguments to call to get the SQL:

      DB[:items].with_sql(:insert_sql, :b=>1) # INSERT INTO items (b) VALUES (1)

         # File lib/sequel/dataset/query.rb, line 955
    955:     def with_sql(sql, *args)
    956:       if sql.is_a?(Symbol)
    957:         sql = send(sql, *args)
    958:       else
    959:         sql = SQL::PlaceholderLiteralString.new(sql, args) unless args.empty?
    960:       end
    961:       clone(:sql=>sql)
    962:     end

### Protected Instance Methods

_import(columns, values, opts) click to toggle source

Internals of #. If primary key values are requested, use separate insert commands for each row. Otherwise, call # and execute each statement it gives separately.

         # File lib/sequel/dataset/actions.rb, line 626
    626:     def _import(columns, values, opts)
    627:       trans_opts = opts.merge(:server=>@opts[:server])
    628:       if opts[:return] == :primary_key
    629:         @db.transaction(trans_opts){values.map{|v| insert(columns, v)}}
    630:       else
    631:         stmts = multi_insert_sql(columns, values)
    632:         @db.transaction(trans_opts){stmts.each{|st| execute_dui(st)}}
    633:       end
    634:     end

_insert_sql() click to toggle source

Formats in INSERT statement using the stored columns and values.

         # File lib/sequel/dataset/sql.rb, line 714
    714:     def _insert_sql
    715:       clause_sql(:insert)
    716:     end

_select_map_multiple(ret_cols) click to toggle source

Return an array of arrays of values given by the symbols in ret_cols.

         # File lib/sequel/dataset/actions.rb, line 637
    637:     def _select_map_multiple(ret_cols)
    638:       map{|r| r.values_at(*ret_cols)}
    639:     end

_select_map_single() click to toggle source

Returns an array of the first value in each row.

         # File lib/sequel/dataset/actions.rb, line 642
    642:     def _select_map_single
    643:       map{|r| r.values.first}
    644:     end

_update_sql() click to toggle source

Formats an UPDATE statement using the stored values.

         # File lib/sequel/dataset/sql.rb, line 719
    719:     def _update_sql
    720:       clause_sql(:update)
    721:     end

compound_clone(type, dataset, opts) click to toggle source

Add the dataset to the list of compounds

         # File lib/sequel/dataset/query.rb, line 967
    967:     def compound_clone(type, dataset, opts)
    968:       if hoist_cte?(dataset)
    969:         s, ds = hoist_cte(dataset)
    970:         return s.compound_clone(type, ds, opts)
    971:       end
    972:       ds = compound_from_self.clone(:compounds=>Array(@opts[:compounds]).map{|x| x.dup} + [[type, dataset.compound_from_self, opts[:all]]])
    973:       opts[:from_self] == false ? ds : ds.from_self(opts)
    974:     end

compound_from_self() click to toggle source

Return a from_self dataset if an order or limit is specified, so it works as expected with UNION, EXCEPT, and INTERSECT clauses.

         # File lib/sequel/dataset/sql.rb, line 725
    725:     def compound_from_self
    726:       (@opts[:limit] || @opts[:order]) ? from_self : self
    727:     end

options_overlap(opts) click to toggle source

Return true if the dataset has a non-nil value for any key in opts.

         # File lib/sequel/dataset/query.rb, line 977
    977:     def options_overlap(opts)
    978:       !(@opts.collect{|k,v| k unless v.nil?}.compact & opts).empty?
    979:     end

simple_select_all?() click to toggle source

Whether this dataset is a simple SELECT * FROM table.

         # File lib/sequel/dataset/query.rb, line 982
    982:     def simple_select_all?
    983:       o = @opts.reject{|k,v| v.nil? || NON_SQL_OPTIONS.include?(k)}
    984:       o.length == 1 && (f = o[:from]) && f.length == 1 && (f.first.is_a?(Symbol) || f.first.is_a?(SQL::AliasedExpression))
    985:     end

to_prepared_statement(type, values=nil) click to toggle source

Return a cloned copy of the current dataset extended with PreparedStatementMethods, setting the type and modify values.

         # File lib/sequel/dataset/prepared_statements.rb, line 254
    254:     def to_prepared_statement(type, values=nil)
    255:       ps = bind
    256:       ps.extend(PreparedStatementMethods)
    257:       ps.orig_dataset = self
    258:       ps.prepared_type = type
    259:       ps.prepared_modify_values = values
    260:       ps
    261:     end

### Private Instance Methods

_filter(clause, *cond, &block) click to toggle source

Internal filter method so it works on either the having or where clauses.

          # File lib/sequel/dataset/query.rb, line 1003
    1003:     def _filter(clause, *cond, &block)
    1004:       _filter_or_exclude(false, clause, *cond, &block)
    1005:     end

_filter_or_exclude(invert, clause, *cond, &block) click to toggle source

Internal filter/exclude method so it works on either the having or where clauses.

          # File lib/sequel/dataset/query.rb, line 990
     990:     def _filter_or_exclude(invert, clause, *cond, &block)
     991:       cond = cond.first if cond.size == 1
     992:       if cond.respond_to?(:empty?) && cond.empty? && !block
     993:         clone
     994:       else
     995:         cond = filter_expr(cond, &block)
     996:         cond = SQL::BooleanExpression.invert(cond) if invert
     997:         cond = SQL::BooleanExpression.new(:AND, @opts[clause], cond) if @opts[clause]
     998:         clone(clause => cond)
     999:       end
    1000:     end

_select_map(column, order, &block) click to toggle source

Internals of `select_map` and `select_order_map`

         # File lib/sequel/dataset/actions.rb, line 649
    649:     def _select_map(column, order, &block)
    650:       ds = naked.ungraphed
    651:       columns = Array(column)
    652:       virtual_row_columns(columns, block)
    653:       select_cols = order ? columns.map{|c| c.is_a?(SQL::OrderedExpression) ? c.expression : c} : columns
    654:       ds = ds.select(*select_cols)
    655:       ds = ds.order(*columns.map{|c| unaliased_identifier(c)}) if order
    656:       if column.is_a?(Array) || (columns.length > 1)
    657:         ds._select_map_multiple(select_cols.map{|c| hash_key_symbol(c)})
    658:       else
    659:         ds._select_map_single
    660:       end
    661:     end

_truncate_sql(table) click to toggle source

Formats the truncate statement. Assumes the table given has already been literalized.

         # File lib/sequel/dataset/sql.rb, line 733
    733:     def _truncate_sql(table)
    734:       "TRUNCATE TABLE #{table}"
    735:     end

affected_rows(conn) click to toggle source

Try to get an accurate number of rows matched using the query info. Fall back to affected_rows if there was no match, but that may be inaccurate.

         # File lib/sequel/adapters/mysql.rb, line 355
    355:       def affected_rows(conn)
    356:         s = conn.info
    357:         if s && s =~ AFFECTED_ROWS_RE
    358:           $1.to_i
    359:         else
    360:           conn.affected_rows
    361:         end
    362:       end

aggregate_dataset() click to toggle source

Clone of this dataset usable in aggregate operations. Does a from_self if dataset contains any parameters that would affect normal aggregation, or just removes an existing order if not.

         # File lib/sequel/dataset/sql.rb, line 776
    776:     def aggregate_dataset
    777:       options_overlap(COUNT_FROM_SELF_OPTS) ? from_self : unordered
    778:     end

alias_alias_symbol(s) click to toggle source

Returns an appropriate symbol for the alias represented by s.

         # File lib/sequel/dataset/sql.rb, line 738
    738:     def alias_alias_symbol(s)
    739:       case s
    740:       when Symbol
    741:         s
    742:       when String
    743:         s.to_sym
    744:       when SQL::Identifier
    745:         s.value.to_s.to_sym
    746:       else
    747:         raise Error, "Invalid alias for alias_alias_symbol: #{s.inspect}"
    748:       end
    749:     end

alias_symbol(sym) click to toggle source

Returns an appropriate alias symbol for the given object, which can be a Symbol, String, SQL::Identifier, SQL::QualifiedIdentifier, or SQL::AliasedExpression.

         # File lib/sequel/dataset/sql.rb, line 754
    754:     def alias_symbol(sym)
    755:       case sym
    756:       when Symbol
    757:         s, t, a = split_symbol(sym)
    758:         a || s ? (a || t).to_sym : sym
    759:       when String
    760:         sym.to_sym
    761:       when SQL::Identifier
    762:         sym.value.to_s.to_sym
    763:       when SQL::QualifiedIdentifier
    764:         alias_symbol(sym.column)
    765:       when SQL::AliasedExpression
    766:         alias_alias_symbol(sym.aliaz)
    767:       else
    768:         raise Error, "Invalid alias for alias_symbol: #{sym.inspect}"
    769:       end
    770:     end

argument_list_append(sql, args) click to toggle source

         # File lib/sequel/dataset/sql.rb, line 780
    780:     def argument_list_append(sql, args)
    781:       c = false
    782:       comma = COMMA
    783:       args.each do |a|
    784:         sql << comma if c
    785:         sql << a.to_s
    786:         c ||= true
    787:       end
    788:     end

as_sql_append(sql, aliaz) click to toggle source

SQL fragment for specifying an alias. expression should already be literalized.

         # File lib/sequel/dataset/sql.rb, line 791
    791:     def as_sql_append(sql, aliaz)
    792:       sql << AS
    793:       quote_identifier_append(sql, aliaz)
    794:     end

check_modification_allowed!() click to toggle source

Raise an InvalidOperation exception if deletion is not allowed for this dataset

         # File lib/sequel/dataset/sql.rb, line 798
    798:     def check_modification_allowed!
    799:       raise(InvalidOperation, "Grouped datasets cannot be modified") if opts[:group]
    800:       raise(InvalidOperation, "Joined datasets cannot be modified") if !supports_modifying_joins? && joined_dataset?
    801:     end

clause_sql(type) click to toggle source

Prepare an SQL statement by calling all clause methods for the given statement type.

         # File lib/sequel/dataset/sql.rb, line 804
    804:     def clause_sql(type)
    805:       sql = @opts[:append_sql] || ''
    806:       send("#{type}_clause_methods").each{|x| send(x, sql)}
    807:       sql
    808:     end

column_list_append(sql, columns) click to toggle source

Converts an array of column names into a comma seperated string of column names. If the array is empty, a wildcard (*) is returned.

         # File lib/sequel/dataset/sql.rb, line 812
    812:     def column_list_append(sql, columns)
    813:       if (columns.nil? || columns.empty?)
    814:         sql << WILDCARD
    815:       else
    816:         expression_list_append(sql, columns)
    817:       end
    818:     end

complex_expression_arg_pairs(args) click to toggle source

Yield each two pair of arguments to the block, which should return a string representing the SQL code for those two arguments. If more than 2 arguments are provided, all calls to the block # after the first will have a LiteralString as the first argument, representing the application of the block to the previous arguments.

         # File lib/sequel/dataset/sql.rb, line 826
    826:     def complex_expression_arg_pairs(args)
    827:       case args.length
    828:       when 1
    829:         literal(args.at(0))
    830:       when 2
    831:         yield args.at(0), args.at(1)
    832:       else
    833:         args.inject{|m, a| LiteralString.new(yield(m, a))}
    834:       end
    835:     end

compound_dataset_sql_append(sql, ds) click to toggle source

The SQL to use for the dataset used in a UNION/INTERSECT/EXCEPT clause.

         # File lib/sequel/dataset/sql.rb, line 838
    838:     def compound_dataset_sql_append(sql, ds)
    839:       subselect_sql_append(sql, ds)
    840:     end

convert_type_proc(v) click to toggle source

Return a callable object that will convert any value of `v`’s class to a ruby object. If no callable object can handle `v`’s class, return false so that the negative lookup is cached.

         # File lib/sequel/adapters/jdbc.rb, line 663
    663:       def convert_type_proc(v)
    664:         case v
    665:         when JAVA_BIG_DECIMAL
    666:           DECIMAL_METHOD
    667:         when JAVA_SQL_TIMESTAMP
    668:           method(:convert_type_timestamp)
    669:         when JAVA_SQL_TIME
    670:           TIME_METHOD
    671:         when JAVA_SQL_DATE
    672:           DATE_METHOD
    673:         when JAVA_BUFFERED_READER
    674:           BUFFERED_READER_METHOD
    675:         when JAVA_BYTE_ARRAY
    676:           BYTE_ARRAY_METHOD
    677:         when JAVA_SQL_BLOB
    678:           BLOB_METHOD
    679:         when JAVA_SQL_CLOB
    680:           CLOB_METHOD
    681:         else
    682:           false
    683:         end
    684:       end

convert_type_timestamp(v) click to toggle source

Convert the given Java timestamp to an instance of Sequel.datetime_class.

         # File lib/sequel/adapters/jdbc.rb, line 656
    656:       def convert_type_timestamp(v)
    657:         db.to_application_timestamp([v.getYear + 1900, v.getMonth + 1, v.getDate, v.getHours, v.getMinutes, v.getSeconds, v.getNanos])
    658:       end

cursor_fetch_rows(sql, &block) click to toggle source

Use a cursor to fetch groups of records at a time, yielding them to the block.

         # File lib/sequel/adapters/postgres.rb, line 633
    633:       def cursor_fetch_rows(sql, &block)
    634:         server_opts = {:server=>@opts[:server] || :read_only}
    635:         db.transaction(server_opts) do
    636:           begin
    637:             execute_ddl("DECLARE sequel_cursor NO SCROLL CURSOR WITHOUT HOLD FOR #{sql}", server_opts)
    638:             rows_per_fetch = @opts[:cursor][:rows_per_fetch].to_i
    639:             rows_per_fetch = 1000 if rows_per_fetch <= 0
    640:             fetch_sql = "FETCH FORWARD #{rows_per_fetch} FROM sequel_cursor"
    641:             cols = nil
    642:             # Load columns only in the first fetch, so subsequent fetches are faster
    643:             execute(fetch_sql) do |res|
    644:               cols = fetch_rows_set_cols(res)
    645:               yield_hash_rows(res, cols, &block)
    646:               return if res.ntuples < rows_per_fetch
    647:             end
    648:             loop do
    649:               execute(fetch_sql) do |res|
    650:                 yield_hash_rows(res, cols, &block)
    651:                 return if res.ntuples < rows_per_fetch
    652:               end
    653:             end
    654:           ensure
    655:             execute_ddl("CLOSE sequel_cursor", server_opts)
    656:           end
    657:         end
    658:       end

dataset_alias(number) click to toggle source

The alias to use for datasets, takes a number to make sure the name is unique.

         # File lib/sequel/dataset/sql.rb, line 843
    843:     def dataset_alias(number)
    844:       :"#{DATASET_ALIAS_BASE_NAME}#{number}"
    845:     end

default_server() click to toggle source

Return self if the dataset already has a server, or a cloned dataset with the default server otherwise.

          # File lib/sequel/dataset/query.rb, line 1079
    1079:     def default_server
    1080:       @opts[:server] ? self : clone(:server=>:default)
    1081:     end

default_server_opts(opts) click to toggle source

Set the server to use to :default unless it is already set in the passed opts

         # File lib/sequel/dataset/actions.rb, line 664
    664:     def default_server_opts(opts)
    665:       {:server=>@opts[:server] || :default}.merge(opts)
    666:     end

default_timestamp_format() click to toggle source

The strftime format to use when literalizing the time.

         # File lib/sequel/dataset/sql.rb, line 848
    848:     def default_timestamp_format
    849:       requires_sql_standard_datetimes? ? STANDARD_TIMESTAMP_FORMAT : TIMESTAMP_FORMAT
    850:     end

delete_clause_methods() click to toggle source

The order of methods to call to build the DELETE SQL statement

         # File lib/sequel/dataset/sql.rb, line 853
    853:     def delete_clause_methods
    854:       DELETE_CLAUSE_METHODS
    855:     end

delete_delete_sql(sql) click to toggle source

         # File lib/sequel/dataset/sql.rb, line 857
    857:     def delete_delete_sql(sql)
    858:       sql << DELETE
    859:     end

delete_from_sql(sql) click to toggle source
Alias for: select_from_sql
delete_order_sql(sql) click to toggle source
Alias for: select_order_sql
delete_returning_sql(sql) click to toggle source
Alias for: insert_returning_sql
delete_where_sql(sql) click to toggle source
Alias for: select_where_sql
delete_with_sql(sql) click to toggle source
Alias for: select_with_sql
empty_array_value(op, cols) click to toggle source

         # File lib/sequel/dataset/sql.rb, line 873
    873:     def empty_array_value(op, cols)
    874:       if Sequel.empty_array_handle_nulls
    875:         c = Array(cols)
    876:         SQL::BooleanExpression.from_value_pairs(c.zip(c), :AND, op == :IN)
    877:       else
    878:         {1 => ((op == :IN) ? 0 : 1)}
    879:       end
    880:     end

execute(sql, opts={}, &block) click to toggle source

Set the :type option to :select if it hasn’t been set.

         # File lib/sequel/adapters/mysql.rb, line 365
    365:       def execute(sql, opts={}, &block)
    366:         super(sql, {:type=>:select}.merge(opts), &block)
    367:       end

execute(sql, opts={}, &block) click to toggle source

Execute the given select SQL on the database using execute. Use the :read_only server unless a specific server is set.

         # File lib/sequel/dataset/actions.rb, line 670
    670:     def execute(sql, opts={}, &block)
    671:       @db.execute(sql, {:server=>@opts[:server] || :read_only}.merge(opts), &block)
    672:     end

execute_ddl(sql, opts={}, &block) click to toggle source

Execute the given SQL on the database using execute_ddl.

         # File lib/sequel/dataset/actions.rb, line 675
    675:     def execute_ddl(sql, opts={}, &block)
    676:       @db.execute_ddl(sql, default_server_opts(opts), &block)
    677:       nil
    678:     end

execute_dui(sql, opts={}, &block) click to toggle source

Execute the given SQL on the database using execute_dui.

         # File lib/sequel/dataset/actions.rb, line 681
    681:     def execute_dui(sql, opts={}, &block)
    682:       @db.execute_dui(sql, default_server_opts(opts), &block)
    683:     end

execute_dui(sql, opts={}, &block) click to toggle source

Set the :type option to :dui if it hasn’t been set.

         # File lib/sequel/adapters/mysql.rb, line 370
    370:       def execute_dui(sql, opts={}, &block)
    371:         super(sql, {:type=>:dui}.merge(opts), &block)
    372:       end

execute_insert(sql, opts={}, &block) click to toggle source

Execute the given SQL on the database using execute_insert.

         # File lib/sequel/dataset/actions.rb, line 686
    686:     def execute_insert(sql, opts={}, &block)
    687:       @db.execute_insert(sql, default_server_opts(opts), &block)
    688:     end

expression_list_append(sql, columns) click to toggle source

Converts an array of expressions into a comma separated string of expressions.

         # File lib/sequel/dataset/sql.rb, line 863
    863:     def expression_list_append(sql, columns)
    864:       c = false
    865:       co = COMMA
    866:       columns.each do |col|
    867:         sql << co if c
    868:         literal_append(sql, col)
    869:         c ||= true
    870:       end
    871:     end

fetch_rows_set_cols(res) click to toggle source

Set the @columns based on the result set, and return the array of field numers, type conversion procs, and name symbol arrays.

         # File lib/sequel/adapters/postgres.rb, line 662
    662:       def fetch_rows_set_cols(res)
    663:         cols = []
    664:         procs = db.conversion_procs
    665:         res.nfields.times do |fieldnum|
    666:           cols << [fieldnum, procs[res.ftype(fieldnum)], output_identifier(res.fname(fieldnum))]
    667:         end
    668:         @columns = cols.map{|c| c.at(2)}
    669:         cols
    670:       end

filter_expr(expr = nil, &block) click to toggle source

SQL expression object based on the expr type. See `filter`.

          # File lib/sequel/dataset/query.rb, line 1008
    1008:     def filter_expr(expr = nil, &block)
    1009:       expr = nil if expr == []
    1010:       if expr && block
    1011:         return SQL::BooleanExpression.new(:AND, filter_expr(expr), filter_expr(block))
    1012:       elsif block
    1013:         expr = block
    1014:       end
    1015:       case expr
    1016:       when Hash
    1017:         SQL::BooleanExpression.from_value_pairs(expr)
    1018:       when Array
    1019:         if (sexpr = expr.at(0)).is_a?(String)
    1020:           SQL::PlaceholderLiteralString.new(sexpr, expr[1..1], true)
    1021:         elsif Sequel.condition_specifier?(expr)
    1022:           SQL::BooleanExpression.from_value_pairs(expr)
    1023:         else
    1024:           SQL::BooleanExpression.new(:AND, *expr.map{|x| filter_expr(x)})
    1025:         end
    1026:       when Proc
    1027:         filter_expr(Sequel.virtual_row(&expr))
    1028:       when SQL::NumericExpression, SQL::StringExpression
    1029:         raise(Error, "Invalid SQL Expression type: #{expr.inspect}")
    1030:       when Symbol, SQL::Expression
    1031:         expr
    1032:       when TrueClass, FalseClass
    1033:         if supports_where_true?
    1034:           SQL::BooleanExpression.new(:NOOP, expr)
    1035:         elsif expr
    1036:           SQL::Constants::SQLTRUE
    1037:         else
    1038:           SQL::Constants::SQLFALSE
    1039:         end
    1040:       when String
    1041:         LiteralString.new("(#{expr})")
    1042:       else
    1043:         raise(Error, 'Invalid filter argument')
    1044:       end
    1045:     end

format_timestamp(v) click to toggle source

Format the timestamp based on the default_timestamp_format, with a couple of modifiers. First, allow %N to be used for fractions seconds (if the database supports them), and override %z to always use a numeric offset of hours and minutes.

         # File lib/sequel/dataset/sql.rb, line 886
    886:     def format_timestamp(v)
    887:       v2 = db.from_application_timestamp(v)
    888:       fmt = default_timestamp_format.gsub(FORMAT_TIMESTAMP_RE) do |m|
    889:         if m == FORMAT_USEC
    890:           format_timestamp_usec(v.is_a?(DateTime) ? v.sec_fraction*(RUBY_VERSION < '1.9.0' ? 86400000000 : 1000000) : v.usec) if supports_timestamp_usecs?
    891:         else
    892:           if supports_timestamp_timezones?
    893:             # Would like to just use %z format, but it doesn't appear to work on Windows
    894:             # Instead, the offset fragment is constructed manually
    895:             minutes = (v2.is_a?(DateTime) ? v2.offset * 1440 : v2.utc_offset/60).to_i
    896:             format_timestamp_offset(*minutes.divmod(60))
    897:           end
    898:         end
    899:       end
    900:       v2.strftime(fmt)
    901:     end

format_timestamp_offset(hour, minute) click to toggle source

Return the SQL timestamp fragment to use for the timezone offset.

         # File lib/sequel/dataset/sql.rb, line 904
    904:     def format_timestamp_offset(hour, minute)
    905:       sprintf(FORMAT_OFFSET, hour, minute)
    906:     end

format_timestamp_usec(usec) click to toggle source

Return the SQL timestamp fragment to use for the fractional time part. Should start with the decimal point. Uses 6 decimal places by default.

         # File lib/sequel/dataset/sql.rb, line 910
    910:     def format_timestamp_usec(usec)
    911:       sprintf(FORMAT_TIMESTAMP_USEC, usec)
    912:     end

graph_alias_columns(graph_aliases) click to toggle source

Transform the hash of graph aliases and return a two element array where the first element is an array of identifiers suitable to pass to a select method, and the second is a new hash of preprocessed graph aliases.

         # File lib/sequel/dataset/graph.rb, line 248
    248:     def graph_alias_columns(graph_aliases)
    249:       gas = {}
    250:       identifiers = graph_aliases.collect do |col_alias, tc|
    251:         table, column, value = Array(tc)
    252:         column ||= col_alias
    253:         gas[col_alias] = [table, column]
    254:         identifier = value || SQL::QualifiedIdentifier.new(table, column)
    255:         identifier = SQL::AliasedExpression.new(identifier, col_alias) if value || column != col_alias
    256:         identifier
    257:       end
    258:       [identifiers, gas]
    259:     end

graph_each() click to toggle source

Fetch the rows, split them into component table parts, tranform and run the row_proc on each part (if applicable), and yield a hash of the parts.

         # File lib/sequel/dataset/graph.rb, line 264
    264:     def graph_each
    265:       # Reject tables with nil datasets, as they are excluded from
    266:       # the result set
    267:       datasets = @opts[:graph][:table_aliases].to_a.reject{|ta,ds| ds.nil?}
    268:       # Get just the list of table aliases into a local variable, for speed
    269:       table_aliases = datasets.collect{|ta,ds| ta}
    270:       # Get an array of arrays, one for each dataset, with
    271:       # the necessary information about each dataset, for speed
    272:       datasets = datasets.collect{|ta, ds| [ta, ds, ds.row_proc]}
    273:       # Use the manually set graph aliases, if any, otherwise
    274:       # use the ones automatically created by .graph
    275:       column_aliases = @opts[:graph_aliases] || @opts[:graph][:column_aliases]
    276:       fetch_rows(select_sql) do |r|
    277:         graph = {}
    278:         # Create the sub hashes, one per table
    279:         table_aliases.each{|ta| graph[ta]={}}
    280:         # Split the result set based on the column aliases
    281:         # If there are columns in the result set that are
    282:         # not in column_aliases, they are ignored
    283:         column_aliases.each do |col_alias, tc|
    284:           ta, column = tc
    285:           graph[ta][column] = r[col_alias]
    286:         end
    287:         # For each dataset run the row_proc if applicable
    288:         datasets.each do |ta,ds,rp|
    289:           g = graph[ta]
    290:           graph[ta] = if g.values.any?{|x| !x.nil?}
    291:             rp ? rp.call(g) : g
    292:           else
    293:             nil
    294:           end
    295:         end
    296:
    297:         yield graph
    298:       end
    299:       self
    300:     end

hash_key_symbol(s) click to toggle source

Return a plain symbol given a potentially qualified or aliased symbol, specifying the symbol that is likely to be used as the hash key for the column when records are returned.

         # File lib/sequel/dataset/actions.rb, line 693
    693:     def hash_key_symbol(s)
    694:       case s
    695:       when Symbol
    696:         _, c, a = split_symbol(s)
    697:         (a || c).to_sym
    698:       when SQL::Identifier
    699:         hash_key_symbol(s.value)
    700:       when SQL::QualifiedIdentifier
    701:         hash_key_symbol(s.column)
    702:       when SQL::AliasedExpression
    703:         hash_key_symbol(s.aliaz)
    704:       when String
    705:         s.to_sym
    706:       else
    707:         raise(Error, "#{s.inspect} is not supported, should be a Symbol, String, SQL::Identifier, SQL::QualifiedIdentifier, or SQL::AliasedExpression")
    708:       end
    709:     end

hoist_cte(ds) click to toggle source

Return two datasets, the first a clone of the receiver with the WITH clause from the given dataset added to it, and the second a clone of the given dataset with the WITH clause removed.

          # File lib/sequel/dataset/query.rb, line 1050
    1050:     def hoist_cte(ds)
    1051:       [clone(:with => (opts[:with] || []) + ds.opts[:with]), ds.clone(:with => nil)]
    1052:     end

hoist_cte?(ds) click to toggle source

Whether CTEs need to be hoisted from the given ds into the current ds.

          # File lib/sequel/dataset/query.rb, line 1055
    1055:     def hoist_cte?(ds)
    1056:       ds.is_a?(Dataset) && ds.opts[:with] && !supports_cte_in_subqueries?
    1057:     end

identifier_append(sql, t) click to toggle source
Alias for: table_ref_append
input_identifier(v) click to toggle source

Modify the identifier returned from the database based on the identifier_output_method.

         # File lib/sequel/dataset/sql.rb, line 916
    916:     def input_identifier(v)
    917:       (i = identifier_input_method) ? v.to_s.send(i) : v.to_s
    918:     end

insert_clause_methods() click to toggle source

The order of methods to call to build the INSERT SQL statement

         # File lib/sequel/dataset/sql.rb, line 927
    927:     def insert_clause_methods
    928:       INSERT_CLAUSE_METHODS
    929:     end

insert_columns_sql(sql) click to toggle source

SQL fragment specifying the columns to insert into

         # File lib/sequel/dataset/sql.rb, line 932
    932:     def insert_columns_sql(sql)
    933:       columns = opts[:columns]
    934:       if columns && !columns.empty?
    935:         sql << PAREN_SPACE_OPEN
    936:         c = false
    937:         co = COMMA
    938:         columns.each do |col|
    939:           sql << co if c
    940:           if col.is_a?(String) && !col.is_a?(LiteralString)
    941:             quote_identifier_append(sql, col)
    942:           else
    943:             literal_append(sql, col)
    944:           end
    945:           c ||= true
    946:         end
    947:         sql << PAREN_CLOSE
    948:       end
    949:     end

insert_insert_sql(sql) click to toggle source

         # File lib/sequel/dataset/sql.rb, line 951
    951:     def insert_insert_sql(sql)
    952:       sql << INSERT
    953:     end

insert_into_sql(sql) click to toggle source

SQL fragment specifying the table to insert INTO

         # File lib/sequel/dataset/sql.rb, line 921
    921:     def insert_into_sql(sql)
    922:       sql << INTO
    923:       source_list_append(sql, @opts[:from])
    924:     end

insert_returning_sql(sql) click to toggle source

SQL fragment specifying the values to return.

         # File lib/sequel/dataset/sql.rb, line 976
    976:     def insert_returning_sql(sql)
    977:       if opts.has_key?(:returning)
    978:         sql << RETURNING
    979:         column_list_append(sql, Array(opts[:returning]))
    980:       end
    981:     end

Also aliased as: delete_returning_sql, update_returning_sql
insert_supports_empty_values?() click to toggle source

Whether insert(nil) or insert({}) must be emulated by using at least one value, false by default.

         # File lib/sequel/dataset/features.rb, line 153
    153:     def insert_supports_empty_values?
    154:       true
    155:     end

insert_values_sql(sql) click to toggle source

SQL fragment specifying the values to insert.

         # File lib/sequel/dataset/sql.rb, line 956
    956:     def insert_values_sql(sql)
    957:       case values = opts[:values]
    958:       when Array
    959:         if values.empty?
    960:           sql << DEFAULT_VALUES
    961:         else
    962:           sql << VALUES
    963:           literal_append(sql, values)
    964:         end
    965:       when Dataset
    966:         sql << SPACE
    967:         subselect_sql_append(sql, values)
    968:       when LiteralString
    969:         sql << SPACE << values
    970:       else
    971:         raise Error, "Unsupported INSERT values type, should be an Array or Dataset: #{values.inspect}"
    972:       end
    973:     end

insert_with_sql(sql) click to toggle source
Alias for: select_with_sql
invert_order(order) click to toggle source

Inverts the given order by breaking it into a list of column references and inverting them.

      DB[:items].invert_order([:id.desc]]) #=> [:id]
      DB[:items].invert_order(:category, :price.desc]) #=> [:category.desc, :price]

          # File lib/sequel/dataset/query.rb, line 1064
    1064:     def invert_order(order)
    1065:       return nil unless order
    1066:       new_order = []
    1067:       order.map do |f|
    1068:         case f
    1069:         when SQL::OrderedExpression
    1070:           f.invert
    1071:         else
    1072:           SQL::OrderedExpression.new(f)
    1073:         end
    1074:       end
    1075:     end

join_type_sql(join_type) click to toggle source

SQL fragment specifying a JOIN type, converts underscores to spaces and upcases.

         # File lib/sequel/dataset/sql.rb, line 987
    987:     def join_type_sql(join_type)
    988:       "#{join_type.to_s.gsub(UNDERSCORE, SPACE).upcase} JOIN"
    989:     end

joined_dataset?() click to toggle source

Whether this dataset is a joined dataset

         # File lib/sequel/dataset/sql.rb, line 992
    992:     def joined_dataset?
    993:      (opts[:from].is_a?(Array) && opts[:from].size > 1) || opts[:join]
    994:     end

literal_array_append(sql, v) click to toggle source

SQL fragment for Array. Treats as an expression if an array of all two pairs, or as a SQL array otherwise.

          # File lib/sequel/dataset/sql.rb, line 997
     997:     def literal_array_append(sql, v)
     998:       if Sequel.condition_specifier?(v)
     999:         literal_expression_append(sql, SQL::BooleanExpression.from_value_pairs(v))
    1000:       else
    1001:         array_sql_append(sql, v)
    1002:       end
    1003:     end

literal_big_decimal(v) click to toggle source

SQL fragment for BigDecimal

          # File lib/sequel/dataset/sql.rb, line 1006
    1006:     def literal_big_decimal(v)
    1007:       d = v.to_s("F")
    1008:       v.nan? || v.infinite? ?  "'#{d}'" : d
    1009:     end

literal_blob_append(sql, v) click to toggle source

Use the driver’s escape_bytea

         # File lib/sequel/adapters/postgres.rb, line 673
    673:       def literal_blob_append(sql, v)
    674:         sql << "'" << db.synchronize{|c| c.escape_bytea(v)} << "'"
    675:       end

literal_blob_append(sql, v) click to toggle source

SQL fragment for SQL::Blob

          # File lib/sequel/dataset/sql.rb, line 1012
    1012:     def literal_blob_append(sql, v)
    1013:       literal_string_append(sql, v)
    1014:     end

literal_dataset_append(sql, v) click to toggle source

SQL fragment for Dataset. Does a subselect inside parantheses.

          # File lib/sequel/dataset/sql.rb, line 1017
    1017:     def literal_dataset_append(sql, v)
    1018:       sql << PAREN_OPEN
    1019:       subselect_sql_append(sql, v)
    1020:       sql << PAREN_CLOSE
    1021:     end

literal_date(v) click to toggle source

SQL fragment for Date, using the ISO8601 format.

          # File lib/sequel/dataset/sql.rb, line 1024
    1024:     def literal_date(v)
    1025:       if requires_sql_standard_datetimes?
    1026:         v.strftime(FORMAT_DATE_STANDARD)
    1027:       else
    1028:         v.strftime(FORMAT_DATE)
    1029:       end
    1030:     end

literal_datetime(v) click to toggle source

SQL fragment for DateTime

          # File lib/sequel/dataset/sql.rb, line 1033
    1033:     def literal_datetime(v)
    1034:       format_timestamp(v)
    1035:     end

literal_expression_append(sql, v) click to toggle source

SQL fragment for SQL::Expression, result depends on the specific type of expression.

          # File lib/sequel/dataset/sql.rb, line 1038
    1038:     def literal_expression_append(sql, v)
    1039:       v.to_s_append(self, sql)
    1040:     end

literal_false() click to toggle source

SQL fragment for false

          # File lib/sequel/dataset/sql.rb, line 1043
    1043:     def literal_false
    1044:       BOOL_FALSE
    1045:     end

literal_float(v) click to toggle source

SQL fragment for Float

          # File lib/sequel/dataset/sql.rb, line 1048
    1048:     def literal_float(v)
    1049:       v.to_s
    1050:     end

literal_hash_append(sql, v) click to toggle source

SQL fragment for Hash, treated as an expression

          # File lib/sequel/dataset/sql.rb, line 1053
    1053:     def literal_hash_append(sql, v)
    1054:       literal_expression_append(sql, SQL::BooleanExpression.from_value_pairs(v))
    1055:     end

literal_integer(v) click to toggle source

SQL fragment for Integer

          # File lib/sequel/dataset/sql.rb, line 1058
    1058:     def literal_integer(v)
    1059:       v.to_s
    1060:     end

literal_nil() click to toggle source

SQL fragment for nil

          # File lib/sequel/dataset/sql.rb, line 1063
    1063:     def literal_nil
    1064:       NULL
    1065:     end

literal_other_append(sql, v) click to toggle source

         # File lib/sequel/adapters/oracle.rb, line 421
    421:       def literal_other_append(sql, v)
    422:         case v
    423:         when OraDate
    424:           literal_append(sql, db.to_application_timestamp(v))
    425:         when OCI8::CLOB
    426:           v.rewind
    427:           literal_append(sql, v.read)
    428:         else
    429:           super
    430:         end
    431:       end

literal_other_append(sql, v) click to toggle source

SQL fragment for a type of object not handled by Dataset#literal. Calls `sql_literal` if object responds to it, otherwise raises an error. Classes implementing `sql_literal` should call a class-specific method on the dataset provided and should add that method to Sequel::Dataset, allowing for adapters to provide customized literalizations. If a database specific type is allowed, this should be overriden in a subclass.

          # File lib/sequel/dataset/sql.rb, line 1073
    1073:     def literal_other_append(sql, v)
    1074:       if v.respond_to?(:sql_literal_append)
    1075:         v.sql_literal_append(self, sql)
    1076:       elsif v.respond_to?(:sql_literal)
    1077:         sql << v.sql_literal(self)
    1078:       else
    1079:         raise Error, "can't express #{v.inspect} as a SQL literal"
    1080:       end
    1081:     end

literal_sqltime(v) click to toggle source

SQL fragment for Sequel::SQLTime, containing just the time part

          # File lib/sequel/dataset/sql.rb, line 1084
    1084:     def literal_sqltime(v)
    1085:       v.strftime("'%H:%M:%S#{format_timestamp_usec(v.usec) if supports_timestamp_usecs?}'")
    1086:     end

literal_string_append(sql, v) click to toggle source

SQL fragment for String. Doubles \ and ’ by default.

          # File lib/sequel/dataset/sql.rb, line 1089
    1089:     def literal_string_append(sql, v)
    1090:       sql << APOS << v.gsub(BACKSLASH_RE, QUAD_BACKSLASH).gsub(APOS_RE, DOUBLE_APOS) << APOS
    1091:     end

literal_string_append(sql, v) click to toggle source

Use the driver’s escape_string

         # File lib/sequel/adapters/postgres.rb, line 678
    678:       def literal_string_append(sql, v)
    679:         sql << "'" << db.synchronize{|c| c.escape_string(v)} << "'"
    680:       end

literal_string_append(sql, v) click to toggle source

Handle correct quoting of strings using ::MySQL.quote.

         # File lib/sequel/adapters/mysql.rb, line 375
    375:       def literal_string_append(sql, v)
    376:         sql << "'"
    377:         sql << ::Mysql.quote(v)
    378:         sql << "'"
    379:       end

literal_symbol_append(sql, v) click to toggle source

Converts a symbol into a column name. This method supports underscore notation in order to express qualified (two underscores) and aliased (three underscores) columns:

      dataset.literal(:abc) #=> "abc"
      dataset.literal(:abc___a) #=> "abc AS a"
      dataset.literal(:items__abc) #=> "items.abc"
      dataset.literal(:items__abc___a) #=> "items.abc AS a"

          # File lib/sequel/dataset/sql.rb, line 1101
    1101:     def literal_symbol_append(sql, v)
    1102:       c_table, column, c_alias = split_symbol(v)
    1103:       if c_table
    1104:         quote_identifier_append(sql, c_table)
    1105:         sql << DOT
    1106:       end
    1107:       quote_identifier_append(sql, column)
    1108:       as_sql_append(sql, c_alias) if c_alias
    1109:     end

literal_time(v) click to toggle source

SQL fragment for Time

          # File lib/sequel/dataset/sql.rb, line 1112
    1112:     def literal_time(v)
    1113:       format_timestamp(v)
    1114:     end

literal_true() click to toggle source

SQL fragment for true

          # File lib/sequel/dataset/sql.rb, line 1117
    1117:     def literal_true
    1118:       BOOL_TRUE
    1119:     end

mutation_method(meth, *args, &block) click to toggle source

Modify the receiver with the results of sending the meth, args, and block to the receiver and merging the options of the resulting dataset into the receiver’s options.

        # File lib/sequel/dataset/mutation.rb, line 54
    54:     def mutation_method(meth, *args, &block)
    55:       copy = send(meth, *args, &block)
    56:       @opts.merge!(copy.opts)
    57:       self
    58:     end

offset_returns_row_number_column?() click to toggle source

Whether using an offset returns an extra row number column that should be eliminated, false by default.

         # File lib/sequel/dataset/features.rb, line 159
    159:     def offset_returns_row_number_column?
    160:       false
    161:     end

output_identifier(v) click to toggle source

Modify the identifier returned from the database based on the identifier_output_method.

         # File lib/sequel/dataset/actions.rb, line 713
    713:     def output_identifier(v)
    714:       v = 'untitled' if v == ''
    715:       (i = identifier_output_method) ? v.to_s.send(i).to_sym : v.to_sym
    716:     end

post_load(all_records) click to toggle source

This is run inside .all, after all of the records have been loaded via .each, but before any block passed to all is called. It is called with a single argument, an array of all returned records. Does nothing by default, added to make the model eager loading code simpler.

         # File lib/sequel/dataset/actions.rb, line 722
    722:     def post_load(all_records)
    723:     end

prepare_extend_sproc(ds) click to toggle source

Extend the dataset with the JDBC stored procedure methods.

         # File lib/sequel/adapters/jdbc.rb, line 687
    687:       def prepare_extend_sproc(ds)
    688:         ds.extend(StoredProcedureMethods)
    689:       end

prepared_arg_placeholder() click to toggle source

The argument placeholder. Most databases used unnumbered arguments with question marks, so that is the default.

         # File lib/sequel/dataset/prepared_statements.rb, line 267
    267:     def prepared_arg_placeholder
    268:       PREPARED_ARG_PLACEHOLDER
    269:     end

prepared_arg_placeholder() click to toggle source

         # File lib/sequel/adapters/oracle.rb, line 433
    433:       def prepared_arg_placeholder
    434:         PREPARED_ARG_PLACEHOLDER
    435:       end

process_result_set(result, &block) click to toggle source

Split out from fetch rows to allow processing of JDBC result sets that don’t come from issuing an SQL string.

         # File lib/sequel/adapters/jdbc.rb, line 693
    693:       def process_result_set(result, &block)
    694:         # get column names
    695:         meta = result.getMetaData
    696:         cols = []
    697:         i = 0
    698:         meta.getColumnCount.times{cols << [output_identifier(meta.getColumnLabel(i+=1)), i]}
    699:         columns = cols.map{|c| c.at(0)}
    700:         if opts[:offset] && offset_returns_row_number_column?
    701:           rn = row_number_column
    702:           columns.delete(rn)
    703:         end
    704:         @columns = columns
    705:         ct = @convert_types
    706:         if (ct.nil? ? db.convert_types : ct)
    707:           cols.each{|c| c << nil}
    708:           process_result_set_convert(cols, result, rn, &block)
    709:         else
    710:           process_result_set_no_convert(cols, result, rn, &block)
    711:         end
    712:       ensure
    713:         result.close
    714:       end

process_result_set_convert(cols, result, rn) click to toggle source

Use conversion procs to convert data retrieved from the database. This has been optimized, the algorithm it uses is roughly, for each column value in each row:

- check if the value is truthy (not false/nil)

- if not truthy, return object

- otherwise, see if a conversion method exists for the column. All columns start with a nil conversion proc, since unlike other adapters, Sequel doesn’t get the type of the column when parsing the column metadata.

- if a conversion proc is not false/nil, call it with the object and return the result.

- if a conversion proc has already been looked up and doesn’t exist (false value), return object.

- if a conversion proc hasn’t been looked up yet (nil value), call convert_type_proc to get the conversion method. Cache the result of as the column’s conversion proc to speed up later processing. If the conversion proc exists, call it and return the result, otherwise, return the object.

         # File lib/sequel/adapters/jdbc.rb, line 734
    734:       def process_result_set_convert(cols, result, rn)
    735:         while result.next
    736:           row = {}
    737:           cols.each do |n, i, p|
    738:             v = result.getObject(i)
    739:             row[n] = if v
    740:               if p
    741:                 p.call(v)
    742:               elsif p.nil?
    743:                 cols[i-1][2] = p = convert_type_proc(v)
    744:                 if p
    745:                   p.call(v)
    746:                 else
    747:                   v
    748:                 end
    749:               else
    750:                 v
    751:               end
    752:             else
    753:               v
    754:             end
    755:           end
    756:           row.delete(rn) if rn
    757:           yield row
    758:         end
    759:       end

process_result_set_no_convert(cols, result, rn) click to toggle source

Yield rows without calling any conversion procs. This may yield Java values and not ruby values.

         # File lib/sequel/adapters/jdbc.rb, line 763
    763:       def process_result_set_no_convert(cols, result, rn)
    764:         while result.next
    765:           row = {}
    766:           cols.each{|n, i| row[n] = result.getObject(i)}
    767:           row.delete(rn) if rn
    768:           yield row
    769:         end
    770:       end

qualified_column_name(column, table) click to toggle source

Returns a qualified column name (including a table name) if the column name isn’t already qualified.

          # File lib/sequel/dataset/sql.rb, line 1123
    1123:     def qualified_column_name(column, table)
    1124:       if Symbol === column
    1125:         c_table, column, c_alias = split_symbol(column)
    1126:         unless c_table
    1127:           case table
    1128:           when Symbol
    1129:             schema, table, t_alias = split_symbol(table)
    1130:             t_alias ||= Sequel::SQL::QualifiedIdentifier.new(schema, table) if schema
    1131:           when Sequel::SQL::AliasedExpression
    1132:             t_alias = table.aliaz
    1133:           end
    1134:           c_table = t_alias || table
    1135:         end
    1136:         ::Sequel::SQL::QualifiedIdentifier.new(c_table, column)
    1137:       else
    1138:         column
    1139:       end
    1140:     end

qualified_expression(e, table) click to toggle source

Qualify the given expression e to the given table.

          # File lib/sequel/dataset/sql.rb, line 1143
    1143:     def qualified_expression(e, table)
    1144:       Qualifier.new(self, table).transform(e)
    1145:     end

returning_fetch_rows(sql, &block) click to toggle source

Called by insert/update/delete when returning is used. Yields each row as a plain hash to the block if one is given, or returns an array of plain hashes for all rows if a block is not given

         # File lib/sequel/dataset/actions.rb, line 728
    728:     def returning_fetch_rows(sql, &block)
    729:       if block
    730:         default_server.fetch_rows(sql, &block)
    731:         nil
    732:       else
    733:         rows = []
    734:         default_server.fetch_rows(sql){|r| rows << r}
    735:         rows
    736:       end
    737:     end

select_clause_methods() click to toggle source

The order of methods to call to build the SELECT SQL statement

          # File lib/sequel/dataset/sql.rb, line 1148
    1148:     def select_clause_methods
    1149:       SELECT_CLAUSE_METHODS
    1150:     end

select_columns_sql(sql) click to toggle source

Modify the sql to add the columns selected

          # File lib/sequel/dataset/sql.rb, line 1153
    1153:     def select_columns_sql(sql)
    1154:       sql << SPACE
    1155:       column_list_append(sql, @opts[:select])
    1156:     end

select_compounds_sql(sql) click to toggle source

Modify the sql to add a dataset to the via an EXCEPT, INTERSECT, or UNION clause. This uses a subselect for the compound datasets used, because using parantheses doesn’t work on all databases. I consider this an ugly hack, but can’t I think of a better default.

          # File lib/sequel/dataset/sql.rb, line 1173
    1173:     def select_compounds_sql(sql)
    1174:       return unless c = @opts[:compounds]
    1175:       c.each do |type, dataset, all|
    1176:         sql << SPACE << type.to_s.upcase
    1177:         sql << ALL if all
    1178:         sql << SPACE
    1179:         compound_dataset_sql_append(sql, dataset)
    1180:       end
    1181:     end

select_distinct_sql(sql) click to toggle source

Modify the sql to add the DISTINCT modifier

          # File lib/sequel/dataset/sql.rb, line 1159
    1159:     def select_distinct_sql(sql)
    1160:       if distinct = @opts[:distinct]
    1161:         sql << DISTINCT
    1162:         unless distinct.empty?
    1163:           sql << ON_PAREN
    1164:           expression_list_append(sql, distinct)
    1165:           sql << PAREN_CLOSE
    1166:         end
    1167:       end
    1168:     end

select_from_sql(sql) click to toggle source

Modify the sql to add the list of tables to select FROM

          # File lib/sequel/dataset/sql.rb, line 1184
    1184:     def select_from_sql(sql)
    1185:       if f = @opts[:from]
    1186:         sql << FROM
    1187:         source_list_append(sql, f)
    1188:       end
    1189:     end

Also aliased as: delete_from_sql
select_group_sql(sql) click to toggle source

Modify the sql to add the expressions to GROUP BY

          # File lib/sequel/dataset/sql.rb, line 1193
    1193:     def select_group_sql(sql)
    1194:       if group = @opts[:group]
    1195:         sql << GROUP_BY
    1196:         if go = @opts[:group_options]
    1197:           sql << go.to_s.upcase
    1198:           sql << PAREN_OPEN
    1199:         end
    1200:         expression_list_append(sql, group)
    1201:         sql << PAREN_CLOSE if go
    1202:       end
    1203:     end

select_having_sql(sql) click to toggle source

Modify the sql to add the filter criteria in the HAVING clause

          # File lib/sequel/dataset/sql.rb, line 1206
    1206:     def select_having_sql(sql)
    1207:       if having = @opts[:having]
    1208:         sql << HAVING
    1209:         literal_append(sql, having)
    1210:       end
    1211:     end

select_join_sql(sql) click to toggle source

Modify the sql to add the list of tables to JOIN to

          # File lib/sequel/dataset/sql.rb, line 1214
    1214:     def select_join_sql(sql)
    1215:       if js = @opts[:join]
    1216:         js.each{|j| literal_append(sql, j)}
    1217:       end
    1218:     end

select_limit_sql(sql) click to toggle source

Modify the sql to limit the number of rows returned and offset

          # File lib/sequel/dataset/sql.rb, line 1221
    1221:     def select_limit_sql(sql)
    1222:       if l = @opts[:limit]
    1223:         sql << LIMIT
    1224:         literal_append(sql, l)
    1225:       end
    1226:       if o = @opts[:offset]
    1227:         sql << OFFSET
    1228:         literal_append(sql, o)
    1229:       end
    1230:     end

select_lock_sql(sql) click to toggle source

Modify the sql to support the different types of locking modes.

          # File lib/sequel/dataset/sql.rb, line 1233
    1233:     def select_lock_sql(sql)
    1234:       case l = @opts[:lock]
    1235:       when :update
    1236:         sql << FOR_UPDATE
    1237:       when String
    1238:         sql << SPACE << l
    1239:       end
    1240:     end

select_order_sql(sql) click to toggle source

Modify the sql to add the expressions to ORDER BY

          # File lib/sequel/dataset/sql.rb, line 1243
    1243:     def select_order_sql(sql)
    1244:       if o = @opts[:order]
    1245:         sql << ORDER_BY
    1246:         expression_list_append(sql, o)
    1247:       end
    1248:     end

Also aliased as: delete_order_sql, update_order_sql
select_select_sql(sql) click to toggle source

          # File lib/sequel/dataset/sql.rb, line 1252
    1252:     def select_select_sql(sql)
    1253:       sql << SELECT
    1254:     end

select_where_sql(sql) click to toggle source

Modify the sql to add the filter criteria in the WHERE clause

          # File lib/sequel/dataset/sql.rb, line 1257
    1257:     def select_where_sql(sql)
    1258:       if w = @opts[:where]
    1259:         sql << WHERE
    1260:         literal_append(sql, w)
    1261:       end
    1262:     end

Also aliased as: delete_where_sql, update_where_sql
select_with_sql(sql) click to toggle source

SQL Fragment specifying the WITH clause

          # File lib/sequel/dataset/sql.rb, line 1267
    1267:     def select_with_sql(sql)
    1268:       ws = opts[:with]
    1269:       return if !ws || ws.empty?
    1270:       sql << select_with_sql_base
    1271:       c = false
    1272:       comma = COMMA
    1273:       ws.each do |w|
    1274:         sql << comma if c
    1275:         quote_identifier_append(sql, w[:name])
    1276:         if args = w[:args]
    1277:          sql << PAREN_OPEN
    1278:          argument_list_append(sql, args)
    1279:          sql << PAREN_CLOSE
    1280:         end
    1281:         sql << AS
    1282:         literal_dataset_append(sql, w[:dataset])
    1283:         c ||= true
    1284:       end
    1285:       sql << SPACE
    1286:     end

Also aliased as: delete_with_sql, insert_with_sql, update_with_sql
select_with_sql_base() click to toggle source

The base keyword to use for the SQL WITH clause

          # File lib/sequel/dataset/sql.rb, line 1292
    1292:     def select_with_sql_base
    1293:       SQL_WITH
    1294:     end

source_list_append(sql, sources) click to toggle source

Converts an array of source names into into a comma separated list.

          # File lib/sequel/dataset/sql.rb, line 1297
    1297:     def source_list_append(sql, sources)
    1298:       raise(Error, 'No source specified for query') if sources.nil? || sources == []
    1299:       c = false
    1300:       co = COMMA
    1301:       sources.each do |s|
    1302:         sql << co if c
    1303:         table_ref_append(sql, s)
    1304:         c ||= true
    1305:       end
    1306:     end

split_symbol(sym) click to toggle source

Splits the symbol into three parts. Each part will either be a string or nil.

For columns, these parts are the table, column, and alias. For tables, these parts are the schema, table, and alias.

          # File lib/sequel/dataset/sql.rb, line 1313
    1313:     def split_symbol(sym)
    1314:       case s = sym.to_s
    1315:       when COLUMN_REF_RE1
    1316:         [$1, $2, $3]
    1317:       when COLUMN_REF_RE2
    1318:         [nil, $1, $2]
    1319:       when COLUMN_REF_RE3
    1320:         [$1, $2, nil]
    1321:       else
    1322:         [nil, s, nil]
    1323:       end
    1324:     end

static_sql(sql) click to toggle source

SQL to use if this dataset uses static SQL. Since static SQL can be a PlaceholderLiteralString in addition to a String, we literalize nonstrings.

          # File lib/sequel/dataset/sql.rb, line 1329
    1329:     def static_sql(sql)
    1330:       if append_sql = @opts[:append_sql]
    1331:         if sql.is_a?(String)
    1332:           append_sql << sql
    1333:         else
    1334:           literal_append(append_sql, sql)
    1335:         end
    1336:       else
    1337:         if sql.is_a?(String)
    1338:           sql
    1339:         else
    1340:           literal(sql)
    1341:         end
    1342:       end
    1343:     end

subselect_sql_append(sql, ds) click to toggle source

SQL fragment for a subselect using the given database’s SQL.

          # File lib/sequel/dataset/sql.rb, line 1346
    1346:     def subselect_sql_append(sql, ds)
    1347:       ds.clone(:append_sql=>sql).sql
    1348:     end

table_ref_append(sql, t) click to toggle source

SQL fragment specifying a table name.

          # File lib/sequel/dataset/sql.rb, line 1351
    1351:     def table_ref_append(sql, t)
    1352:       if t.is_a?(String)
    1353:         quote_identifier_append(sql, t)
    1354:       else
    1355:         literal_append(sql, t)
    1356:       end
    1357:     end

Also aliased as: identifier_append
unaliased_identifier(c) click to toggle source

Return the unaliased part of the identifier. Handles both implicit aliases in symbols, as well as SQL::AliasedExpression objects. Other objects are returned as is.

         # File lib/sequel/dataset/actions.rb, line 742
    742:     def unaliased_identifier(c)
    743:       case c
    744:       when Symbol
    745:         c_table, column, _ = split_symbol(c)
    746:         c_table ? SQL::QualifiedIdentifier.new(c_table, column.to_sym) : column.to_sym
    747:       when SQL::AliasedExpression
    748:         c.expression
    749:       when SQL::OrderedExpression
    750:         expr = c.expression
    751:         if expr.is_a?(Symbol)
    752:           expr = unaliased_identifier(expr)
    753:           SQL::OrderedExpression.new(unaliased_identifier(c.expression), c.descending, :nulls=>c.nulls)
    754:         else
    755:           c
    756:         end
    757:       else
    758:         c
    759:       end
    760:     end

update_clause_methods() click to toggle source

The order of methods to call to build the UPDATE SQL statement

          # File lib/sequel/dataset/sql.rb, line 1361
    1361:     def update_clause_methods
    1362:       UPDATE_CLAUSE_METHODS
    1363:     end

update_order_sql(sql) click to toggle source
Alias for: select_order_sql
update_returning_sql(sql) click to toggle source
Alias for: insert_returning_sql
update_set_sql(sql) click to toggle source

The SQL fragment specifying the columns and values to SET.

          # File lib/sequel/dataset/sql.rb, line 1374
    1374:     def update_set_sql(sql)
    1375:       values = opts[:values]
    1376:       sql << SET
    1377:       if values.is_a?(Hash)
    1378:         values = opts[:defaults].merge(values) if opts[:defaults]
    1379:         values = values.merge(opts[:overrides]) if opts[:overrides]
    1380:         c = false
    1381:         eq = EQUAL
    1382:         values.each do |k, v|
    1383:           sql << COMMA if c
    1384:           if k.is_a?(String) && !k.is_a?(LiteralString)
    1385:             quote_identifier_append(sql, k)
    1386:           else
    1387:             literal_append(sql, k)
    1388:           end
    1389:           sql << eq
    1390:           literal_append(sql, v)
    1391:           c ||= true
    1392:         end
    1393:       else
    1394:         sql << values
    1395:       end
    1396:     end

update_table_sql(sql) click to toggle source

SQL fragment specifying the tables from with to delete. Includes join table if modifying joins is allowed.

          # File lib/sequel/dataset/sql.rb, line 1367
    1367:     def update_table_sql(sql)
    1368:       sql << SPACE
    1369:       source_list_append(sql, @opts[:from])
    1370:       select_join_sql(sql) if supports_modifying_joins?
    1371:     end

update_update_sql(sql) click to toggle source

          # File lib/sequel/dataset/sql.rb, line 1398
    1398:     def update_update_sql(sql)
    1399:       sql << UPDATE
    1400:     end

update_where_sql(sql) click to toggle source
Alias for: select_where_sql
update_with_sql(sql) click to toggle source
Alias for: select_with_sql
uses_returning?(type) click to toggle source

Whether the RETURNING clause is used for the given dataset. `type` can be :insert, :update, or :delete.

         # File lib/sequel/dataset/features.rb, line 165
    165:     def uses_returning?(type)
    166:       opts[:returning] && !@opts[:sql] && supports_returning?(type)
    167:     end

virtual_row_columns(columns, block) click to toggle source

Treat the `block` as a virtual_row block if not `nil` and add the resulting columns to the `columns` array (modifies `columns`).

          # File lib/sequel/dataset/query.rb, line 1085
    1085:     def virtual_row_columns(columns, block)
    1086:       columns.concat(Array(Sequel.virtual_row(&block))) if block
    1087:     end

yield_hash_rows(res, cols) click to toggle source

For each row in the result set, yield a hash with column name symbol keys and typecasted values.

         # File lib/sequel/adapters/postgres.rb, line 684
    684:       def yield_hash_rows(res, cols)
    685:         res.ntuples.times do |recnum|
    686:           converted_rec = {}
    687:           cols.each do |fieldnum, type_proc, fieldsym|
    688:             value = res.getvalue(recnum, fieldnum)
    689:             converted_rec[fieldsym] = (value && type_proc) ? type_proc.call(value) : value
    690:           end
    691:           yield converted_rec
    692:         end
    693:       end

yield_rows(r, cols) click to toggle source

Yield each row of the given result set r with columns cols as a hash with symbol keys

         # File lib/sequel/adapters/mysql.rb, line 383
    383:       def yield_rows(r, cols)
    384:         while row = r.fetch_row
    385:           h = {}
    386:           cols.each{|n, p, i| v = row[i]; h[n] = (v && p) ? p.call(v) : v}
    387:           yield h
    388:         end
    389:       end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.