Book your show here...
HOME
PROMOS
OFFERS
FEEDBACK
CONTACT
1
2
3
4
5
Total seats selected : {{ticket.no}}
Gold
Silver
Make Payment
Booking Summary
Total Tickets {{ticket.no}}
Rs {{ ticket.no * ticket.cat }}
Internate handling Charges
Rs 10
Total Amaount
Rs {{ ticket.no * ticket.cat + 10 }}
Amaount Payable
Rs {{ ticket.no * ticket.cat + 10 }}
Payment Successful


Instructions:
Use this button to load the workflow into the graph. After loading an initial workflow you may use the Load Workflow button on the toolbar.
Drag and drop items from Actions tab into the graph to create a new workflow action. Double click also works.
{{ selectedActionApi.description }}
{{ selectedActionApi.returns.example }}


We are an innovative company integrated of young professionals, devoutly focused to train and modernize ourselves every day in order to offer quality and Excellency in all of our services.We wish to become the favorite solution provider in the technology sector.


Checksum Utility Test
The Checksum Utility Test verifies that the identified content package generated the summary log or the checksum value from the summary log during a successful run of the Content Package Test.


Mom's House is an app where you'll learn how to stablize your mental health and gain positive coping mechanism.
What We OfferTools for you to use to help you approach daily task in a different way.
You're able to talk get in contact with therapist through the app. You can chat via chatbox, phone call, or video call.
A happy game to keep you occupied and happy when you're feeling down.
We'll refer our customer to local resources for others looking for outside sources.
Talk with your therapist whenever and wherever you are, on web or mobile, without scheduling, traveling or worrying about privacy. No internet access? You're welcome to use the self help tools until you're able to contact your therapist.
Virtual therapy is typically 80% cheaper than face-to-face therapy and there are several payment options to choose from
Multiple platforms within the app to use, from talking to a therapist to helping yourself overcome the symptoms you're facing.
All client communication and undergo regular security audits, and our therapists adhere to strict professional and ethical codes regarding client confidentiality
My name is April Bolton, I’m a self driven and avid entry-level technology professional with years of experience in customer service, electronics repair, and website designing. I’m currently taking a coding program in Harlem, with hopes to develop my own app within two years.
Connect On LinkedIn Now!In my senior year of high school, I began to struggle keeping up with my school work, I lacked motivation to go in everyday, I was barely getting any sleep, and experienced many anxiety attacks trying to cope with everything. I had not known that these were some of many symptoms of depression. Since then, I've found that I wasn't the only one going through these feelings and that many people had been confronting with these feelings with poor coping mechanisms. So I created Mom's House, to help my peers overcome their mental health issues and build a community to communicate with others to let them know that things aren't always fine and that's okay. We just have to learn how to manage.


Current
Professional
Experience
source: http://tjvantoll.com/2014/12/29/so-you-want-to-write-a-tech-book/Minneapolis, MN
http://groovy-lang.org/download.html
curl -s get.sdkman.io | bash
sdk install groovy
groovy>println "Hello, Gr8Workshop!"
Hello, Gr8Workshop!
===>null
int i = 10
println i.class.name
-> java.lang.Integer
Integer i = 20
println i.class.name
-> java.lang.Integer
when no type is specified or for a flexible type
def i = 10
println i * 2
-> 20
i = 'abc'
println i * 2
-> abcabc
(examples in console)
(examples in console)
List m = ['a', 'b', 2]
println m[2]
-> 2
m[2] = 3
println m
-> [a, b, 3]
m << 'c'
println m
-> [a, b, 3, c]
m.push(4)
-> [a, b, 3, c, 4]
m.pop()
-> 4
List m = ['a', 'b', 2]
m.multiply(2)
-> ['a', 'b', 2, 'a', 'b', 2]
m * 2
-> ['a', 'b', 2, 'a', 'b', 2]
m + 2
-> ['a', 'b', 2, 2]
(examples in console)
Map m = [val1: 'a', val2: 'b', val3: 2]
println m.val1
-> a
println m['val3']
-> 2
m.val4 = 3
println m
-> [val1:a, val2:b, val3: 2, val4: 3]
println m.keySet()
-> [val1, val2, val3, val4]
println m.values()
-> [a, b, 2, 3]
println (1..10)
-> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
println (1..<10)
-> [1, 2, 3, 4, 5, 6, 7, 8, 9]
Integer timesTwo(x) {
x + x
}
println timesTwo(10)
-> 20
def result = timesTwo 10
println result
-> 20
Code as Data
(to the console)
Closure c = { name, year = 2016 ->
println "Hello, $name $year!"
}
c.call('Gr8Workshop')
-> "Hello, Gr8Workshop 2016!"
c('Gr8Workshop', 2017)
-> "Hello, Gr8Workshop 2017!"
|
this |
instance of the class where the closure was defined |
|
owner |
usually the same as this unless declared inside another closure |
|
delegate |
same as owner but can be reassigned when the closure is passed around |
List dl = []
for(Integer i = 1; i < 4; i++){
dl.add(i * 2)
}
println dl
-> [2, 4, 6]
List dl = []
for(i in [1,2,3]) {
dl << i * 2
}
println dl
-> [2, 4, 6]
List sl = [1, 2, 3]
List dl = []
sl.each { it ->
dl << it * 2
}
println dl
-> [2, 4, 6]
Map m = [va1: 1, var2: 2, var3: 3]
List dl = m.collect { key, value ->
value * 2
}
println dl
-> [2, 4, 6]
(1..3).multiply(2)
-> [1, 2, 3, 1, 2, 3]
(1..3)*.multiply(2)
-> [2, 4, 6]
Let's groovy-fy this code
List l = [-1,2,-3,-17]
List al = []
for ( i in l ) {
al << i.abs()
}
println al
--> [1,2,3,17]
[-1,2,-3,-17]*.abs()
Print the sum of the numbers from 1 to 10
option 1:Integer answer = 0 for(i in [1,2,3,4,5,6,7,8,9,10]) { answer += i } println answer
option 2:Integer answer = 0 (1..10).each { answer = answer + it } println answer
bonus answer:println ( (1..10).sum() )
False values
== verifies value same as .equals()
is verifies object identity
List numbers = [0,1,2,3]
numbers.each {
if(it) {
println it
}
}
-> 1
-> 2
-> 3
Integer myInteger = 2
int myInt = 2
myInteger.is(myInt)
-> true
String world = 'World'
GString myGString = "Hello, $world"
String myString = 'Hello, World'
println myGString
println myString
myGString.is(myString)
-> Hello, World
-> Hello, World
-> false
x ? return x : return 'something else'
x ?: 'something else'
myMap?.propertyA?.propertyB
Map m = [val1: 2, val2: 4, val3: 6]
m.find { it.value % 2 == 0 && it.value % 3 != 0 }
-> val1=2
m.findAll {it.value % 2 == 0 && it.value % 3 != 0 }
-> [val1:2, val2:4]
Map m = [val1: 2, val2: 4, val3: 6]
m.any { it.value % 2 == 0 }
-> true
m.every { it.value % 3 == 0 }
-> false
class Person {
String first
String last
}
Person me = new Person(first: 'Jenn', last: 'Strater')
println me.first
println me.last
-- add String company to class --
me.company = 'Object Partners'
println me.properties
-> [class:class Person, first:Jenn, company:Object Partners, last:Strater]
class Person {
String first
String last
String getFullName() {
this.first + ' ' + this.last
}
}
Person me = new Person(first: 'Jenn', last: 'Strater')
println me.fullName
-> 'Jenn Strater'
(save previous script as people.groovy)
groovy people.groovy
-> Jenn Strater
println doubledValue(10)
def doubledValue(x) {
x * 2
}
def myFile = new File('foo.txt')
myFile.write 'Hello, \n'
myFile.append('Gr8Workshop!')
foo.txt
Hello,
Gr8Workshop!
def myFile = new File('foo.txt')
myFile.eachLine { line ->
def processedLine = line.replaceAll('Hello', 'Hi')
println processedLine
}
-> Hi,
-> Gr8Workshop!
(copy to console)
@Grab(group='org.codehaus.groovy.modules.http-builder', module='http-builder', version='0.7.1')
import groovyx.net.http.RESTClient
def http = new RESTClient("http://www.gr8ladies.org")
http.get(path: '/api/companies') { resp, reader ->
reader.sort { -it.percentageTotalWomen } // sort by percentage women in descending order
reader[0..4].each{ // only the first 5
if(it.totalEmployees) { // if the value of total employees is not 0 (to eliminate companies that didn't report that field)
println 'name:' + it.name
println 'country:' + it.country
println 'total employees: ' + it.totalEmployees
println 'total men: '+ it.totalMen
println 'total women: '+ it.totalWomen + '\n'
}
}
}
return null // don't print the entire result at the end
(copy to console)
@Grab(group='org.codehaus.groovy.modules.http-builder', module='http-builder', version='0.7.1')
import groovyx.net.http.RESTClient
def http = new RESTClient("http://api.icndb.com")
http.get(path: '/jokes/random/5', query: [exclude: 'explicit']) { resp, reader ->
reader.value.joke.each{
println it + '\n'
}
}
Number.metaClass.getDollars = { delegate as BigDecimal }
Number.metaClass.getProperty = { String name ->
def rates = [euros: 1.1f, pesos: 0.063f]
delegate * (rates[name] as BigDecimal)
}
Adding different currencies together
def total = 20.dollars + 40.euros + 200.pesos
assert total == 76.60
class Person {
def methodMissing(String name, args) {
if (name.startsWith('say')) {
String message = (name - 'say').trim()
println message
}
}
}
Trying out our dynamic method
Person you = new Person()
you.sayHello()
you."say You are awesome!"()
jenn@gr8ladies.org


We provide cutting edge training and education in digital fabrication and manufacturing innovation. We offer our individualized and industry specific courses to a variety of universities, companies, industry professional as well as the general public.
How may we help your team?
Contact us, for more details.
We specialize in prototyping for the 21st century. By combining traditional craftsmanship and novel digital fabrication methods, we provide cutting edge solutions to today’s manufacturing challenges. Our team specializes in designing 3D modeling, pattern making and construction of apparel, footwear, and accessories.
We target the vital areas that drive business growth. Our network of trusted professionals deliver operational, financial, and sales support to ensure business success for our clients and partners in Africa, Europe, and USA.
Mezzo Green International, LLC (MGI) drives business results and build lasting relationships around the world.
Our projects and events create experiences that connect with target audiences and bring brands to life.
MGI's innovative projects and training provides unprecedented value to our partners and clients.
Business and Project Director
Chinedu is passionate about the intersection of sustainability and business development. He advises corporations and individual clients on topics ranging from expansion into Africa to strategic marketing campaigns and creating a positive global impact.
Chinedu helps corporations establish viable blueprints for sustainability and responsible growth. He recognizes the individual needs of his clients, offers innovative solutions, and provides them with the tools that they need to succeed. Chinedu has several certifications in Business Management, Entrepreneurship, and Climate Change Leadership.
Design Innovation Specialist
Katherine is an inventor, designer, consultant, and avid researcher of technology, fashion and mass customization of apparel and footwear. Her work in 3D printing and digital fabrication includes prototyping footwear, apparel, 3D printing on fabric, auxetic structures and experimental textiles.
Katherine has earned a B.F.A. in International Fashion Design from the Fashion Institute of Technology, a Master Certification in Footwear Innovation from SLEM Innovation and Training Institute for Footwear and Leather Industries, and has successfully completed Master-level coursework at NYU Tandon School of Engineering.


Senior Researcher IMPA
Leading Scientist of the VISGRAF Laboratory
Mathematics, Art, a bit of Technology ... and a lot of Passion!


Active Record objects don‘t specify their attributes directly, but rather infer them from the table definition with which they‘re linked. Adding, removing, and changing attributes and their type is done directly in the database. Any change is instantly reflected in the Active Record objects. The mapping that binds a given Active Record class to a certain database table will happen automatically in most common cases, but can be overwritten for the uncommon ones.
See the mapping rules in table_name and the full example in files/README.html for more insight.
Active Records accept constructor parameters either in a hash or as a block. The hash method is especially useful when you‘re receiving the data from somewhere else, like an HTTP request. It works like this:
user = User.new(:name => "David", :occupation => "Code Artist") user.name # => "David"
You can also use block initialization:
user = User.new do |u| u.name = "David" u.occupation = "Code Artist" end
And of course you can just create a bare object and specify the attributes after the fact:
user = User.new user.name = "David" user.occupation = "Code Artist"
Conditions can either be specified as a string, array, or hash representing the WHERE-part of an SQL statement. The array form is to be used when the condition input is tainted and requires sanitization. The string form can be used for statements that don‘t involve tainted data. The hash form works much like the array form, except only equality and range is possible. Examples:
class User < ActiveRecord::Base def self.authenticate_unsafely(user_name, password) find(:first, :conditions => "user_name = '#{user_name}' AND password = '#{password}'") end def self.authenticate_safely(user_name, password) find(:first, :conditions => [ "user_name = ? AND password = ?", user_name, password ]) end def self.authenticate_safely_simply(user_name, password) find(:first, :conditions => { :user_name => user_name, :password => password }) end end
The authenticate_unsafely method inserts the parameters directly into the query and is thus susceptible to SQL-injection attacks if the user_name and password parameters come directly from an HTTP request. The authenticate_safely and authenticate_safely_simply both will sanitize the user_name and password before inserting them in the query, which will ensure that an attacker can‘t escape the query and fake the login (or worse).
When using multiple parameters in the conditions, it can easily become hard to read exactly what the fourth or fifth question mark is supposed to represent. In those cases, you can resort to named bind variables instead. That‘s done by replacing the question marks with symbols and supplying a hash with values for the matching symbol keys:
Company.find(:first, :conditions => [ "id = :id AND name = :name AND division = :division AND created_at > :accounting_date", { :id => 3, :name => "37signals", :division => "First", :accounting_date => '2005-01-01' } ])
Similarly, a simple hash without a statement will generate conditions based on equality with the SQL AND operator. For instance:
Student.find(:all, :conditions => { :first_name => "Harvey", :status => 1 }) Student.find(:all, :conditions => params[:student])
A range may be used in the hash to use the SQL BETWEEN operator:
Student.find(:all, :conditions => { :grade => 9..12 })
An array may be used in the hash to use the SQL IN operator:
Student.find(:all, :conditions => { :grade => [9,11,12] })
All column values are automatically available through basic accessors on the Active Record object, but sometimes you want to specialize this behavior. This can be done by overwriting the default accessors (using the same name as the attribute) and calling read_attribute(attr_name) and write_attribute(attr_name, value) to actually change things. Example:
class Song < ActiveRecord::Base # Uses an integer of seconds to hold the length of the song def length=(minutes) write_attribute(:length, minutes.to_i * 60) end def length read_attribute(:length) / 60 end end
You can alternatively use self[:attribute]=(value) and self[:attribute] instead of write_attribute(:attribute, value) and read_attribute(:attribute) as a shorter form.
In addition to the basic accessors, query methods are also automatically available on the Active Record object. Query methods allow you to test whether an attribute value is present.
For example, an Active Record User with the name attribute has a name? method that you can call to determine whether the user has a name:
user = User.new(:name => "David") user.name? # => true anonymous = User.new(:name => "") anonymous.name? # => false
Sometimes you want to be able to read the raw attribute data without having the column-determined typecast run its course first. That can be done by using the <attribute>_before_type_cast accessors that all attributes have. For example, if your Account model has a balance attribute, you can call account.balance_before_type_cast or account.id_before_type_cast.
This is especially useful in validation situations where the user might supply a string for an integer field and you want to display the original string back in an error message. Accessing the attribute normally would typecast the string to 0, which isn‘t what you want.
Dynamic attribute-based finders are a cleaner way of getting (and/or creating) objects by simple queries without turning to SQL. They work by appending the name of an attribute to find_by_ or find_all_by_, so you get finders like Person.find_by_user_name, Person.find_all_by_last_name, and Payment.find_by_transaction_id. So instead of writing Person.find(:first, :conditions => ["user_name = ?", user_name]), you just do Person.find_by_user_name(user_name). And instead of writing Person.find(:all, :conditions => ["last_name = ?", last_name]), you just do Person.find_all_by_last_name(last_name).
It‘s also possible to use multiple attributes in the same find by separating them with "and", so you get finders like Person.find_by_user_name_and_password or even Payment.find_by_purchaser_and_state_and_country. So instead of writing Person.find(:first, :conditions => ["user_name = ? AND password = ?", user_name, password]), you just do Person.find_by_user_name_and_password(user_name, password).
It‘s even possible to use all the additional parameters to find. For example, the full interface for Payment.find_all_by_amount is actually Payment.find_all_by_amount(amount, options). And the full interface to Person.find_by_user_name is actually Person.find_by_user_name(user_name, options). So you could call Payment.find_all_by_amount(50, :order => "created_on").
The same dynamic finder style can be used to create the object if it doesn‘t already exist. This dynamic finder is called with find_or_create_by_ and will return the object if it already exists and otherwise creates it, then returns it. Protected attributes won‘t be set unless they are given in a block. For example:
# No 'Summer' tag exists Tag.find_or_create_by_name("Summer") # equal to Tag.create(:name => "Summer") # Now the 'Summer' tag does exist Tag.find_or_create_by_name("Summer") # equal to Tag.find_by_name("Summer") # Now 'Bob' exist and is an 'admin' User.find_or_create_by_name('Bob', :age => 40) { |u| u.admin = true }
Use the find_or_initialize_by_ finder if you want to return a new record without saving it first. Protected attributes won‘t be setted unless they are given in a block. For example:
# No 'Winter' tag exists winter = Tag.find_or_initialize_by_name("Winter") winter.new_record? # true
To find by a subset of the attributes to be used for instantiating a new object, pass a hash instead of a list of parameters. For example:
Tag.find_or_create_by_name(:name => "rails", :creator => current_user)
That will either find an existing tag named "rails", or create a new one while setting the user that created it.
Active Record can serialize any object in text columns using YAML. To do so, you must specify this with a call to the class method serialize. This makes it possible to store arrays, hashes, and other non-mappable objects without doing any additional work. Example:
class User < ActiveRecord::Base serialize :preferences end user = User.create(:preferences => { "background" => "black", "display" => large }) User.find(user.id).preferences # => { "background" => "black", "display" => large }
You can also specify a class option as the second parameter that‘ll raise an exception if a serialized object is retrieved as a descendent of a class not in the hierarchy. Example:
class User < ActiveRecord::Base serialize :preferences, Hash end user = User.create(:preferences => %w( one two three )) User.find(user.id).preferences # raises SerializationTypeMismatch
Active Record allows inheritance by storing the name of the class in a column that by default is named "type" (can be changed by overwriting Base.inheritance_column). This means that an inheritance looking like this:
class Company < ActiveRecord::Base; end class Firm < Company; end class Client < Company; end class PriorityClient < Client; end
When you do Firm.create(:name => "37signals"), this record will be saved in the companies table with type = "Firm". You can then fetch this row again using Company.find(:first, "name = ‘37signals’") and it will return a Firm object.
If you don‘t have a type column defined in your table, single-table inheritance won‘t be triggered. In that case, it‘ll work just like normal subclasses with no special magic for differentiating between them or reloading the right type with find.
Note, all the attributes for all the cases are kept in the same table. Read more: www.martinfowler.com/eaaCatalog/singleTableInheritance.html
Connections are usually created through ActiveRecord::Base.establish_connection and retrieved by ActiveRecord::Base.connection. All classes inheriting from ActiveRecord::Base will use this connection. But you can also set a class-specific connection. For example, if Course is an ActiveRecord::Base, but resides in a different database, you can just say Course.establish_connection and Course and all of its subclasses will use this connection instead.
This feature is implemented by keeping a connection pool in ActiveRecord::Base that is a Hash indexed by the class. If a connection is requested, the retrieve_connection method will go up the class-hierarchy until a connection is found in the connection pool.
Note: The attributes listed are class-level attributes (accessible from both the class and instance level). So it‘s possible to assign a logger to the class through Base.logger= which will then be used by all instances in the current object space.
| VALID_FIND_OPTIONS | = | [ :conditions, :include, :joins, :limit, :offset, :order, :select, :readonly, :group, :from, :lock ] |
| set_table_name | -> | table_name= |
| set_primary_key | -> | primary_key= |
| set_inheritance_column | -> | inheritance_column= |
| set_sequence_name | -> | sequence_name= |
| sanitize_sql_for_conditions | -> | sanitize_sql |
| sanitize_sql_hash_for_conditions | -> | sanitize_sql_hash |
| sanitize_sql | -> | sanitize_conditions |
| abstract_class | [RW] | Set this to true if this is an abstract class (see abstract_class?). |
Overwrite the default class equality method to provide support for association proxies.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1269 1269: def ===(object) 1270: object.is_a?(self) 1271: end
Returns whether this class is a base AR class. If A is a base class and B descends from A, then B.base_class will return B.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1285 1285: def abstract_class? 1286: defined?(@abstract_class) && @abstract_class == true 1287: end
Specifies a white list of model attributes that can be set via mass-assignment, such as new(attributes), update_attributes(attributes), or attributes=(attributes)
This is the opposite of the attr_protected macro: Mass-assignment will only set attributes in this list, to assign to the rest of attributes you can use direct writer methods. This is meant to protect sensitive attributes from being overwritten by malicious users tampering with URLs or forms. If you‘d rather start from an all-open default and restrict attributes as needed, have a look at attr_protected.
class Customer < ActiveRecord::Base attr_accessible :name, :nickname end customer = Customer.new(:name => "David", :nickname => "Dave", :credit_rating => "Excellent") customer.credit_rating # => nil customer.attributes = { :name => "Jolly fellow", :credit_rating => "Superb" } customer.credit_rating # => nil customer.credit_rating = "Average" customer.credit_rating # => "Average"
# File vendor/rails/activerecord/lib/active_record/base.rb, line 930 930: def attr_accessible(*attributes) 931: write_inheritable_attribute("attr_accessible", Set.new(attributes.map(&:to_s)) + (accessible_attributes || [])) 932: end
Attributes named in this macro are protected from mass-assignment, such as new(attributes), update_attributes(attributes), or attributes=(attributes).
Mass-assignment to these attributes will simply be ignored, to assign to them you can use direct writer methods. This is meant to protect sensitive attributes from being overwritten by malicious users tampering with URLs or forms.
class Customer < ActiveRecord::Base attr_protected :credit_rating end customer = Customer.new("name" => David, "credit_rating" => "Excellent") customer.credit_rating # => nil customer.attributes = { "description" => "Jolly fellow", "credit_rating" => "Superb" } customer.credit_rating # => nil customer.credit_rating = "Average" customer.credit_rating # => "Average"
To start from an all-closed default and enable attributes as needed, have a look at attr_accessible.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 897 897: def attr_protected(*attributes) 898: write_inheritable_attribute("attr_protected", Set.new(attributes.map(&:to_s)) + (protected_attributes || [])) 899: end
Attributes listed as readonly can be set for a new record, but will be ignored in database updates afterwards.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 940 940: def attr_readonly(*attributes) 941: write_inheritable_attribute("attr_readonly", Set.new(attributes.map(&:to_s)) + (readonly_attributes || [])) 942: end
Returns the base AR subclass that this class descends from. If A extends AR::Base, A.base_class will return A. If B descends from A through some arbitrarily deep hierarchy, B.base_class will return A.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1276 1276: def base_class 1277: class_of_active_record_descendant(self) 1278: end
Log and benchmark multiple statements in a single block. Example:
Project.benchmark("Creating project") do project = Project.create("name" => "stuff") project.create_manager("name" => "David") project.milestones << Milestone.find(:all) end
The benchmark is only recorded if the current level of the logger is less than or equal to the log_level, which makes it easy to include benchmarking statements in production software that will remain inexpensive because the benchmark will only be conducted if the log level is low enough.
The logging of the multiple statements is turned off unless use_silence is set to false.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1249 1249: def benchmark(title, log_level = Logger::DEBUG, use_silence = true) 1250: if logger && logger.level <= log_level 1251: result = nil 1252: seconds = Benchmark.realtime { result = use_silence ? silence { yield } : yield } 1253: logger.add(log_level, "#{title} (#{'%.5f' % seconds})") 1254: result 1255: else 1256: yield 1257: end 1258: end
Clears the cache which maps classes to connections.
# File vendor/rails/activerecord/lib/active_record/connection_adapters/abstract/connection_specification.rb, line 84 84: def clear_active_connections! 85: clear_cache!(@@active_connections) do |name, conn| 86: conn.disconnect! 87: end 88: end
Clears the cache which maps classes
# File vendor/rails/activerecord/lib/active_record/connection_adapters/abstract/connection_specification.rb, line 91 91: def clear_reloadable_connections! 92: if @@allow_concurrency 93: # With concurrent connections @@active_connections is 94: # a hash keyed by thread id. 95: @@active_connections.each do |thread_id, conns| 96: conns.each do |name, conn| 97: if conn.requires_reloading? 98: conn.disconnect! 99: @@active_connections[thread_id].delete(name) 100: end 101: end 102: end 103: else 104: @@active_connections.each do |name, conn| 105: if conn.requires_reloading? 106: conn.disconnect! 107: @@active_connections.delete(name) 108: end 109: end 110: end 111: end
Returns an array of column names as strings.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1157 1157: def column_names 1158: @column_names ||= columns.map { |column| column.name } 1159: end
Returns an array of column objects for the table associated with this class.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1143 1143: def columns 1144: unless defined?(@columns) && @columns 1145: @columns = connection.columns(table_name, "#{name} Columns") 1146: @columns.each { |column| column.primary = column.name == primary_key } 1147: end 1148: @columns 1149: end
Returns true if a connection that‘s accessible to this class has already been opened.
# File vendor/rails/activerecord/lib/active_record/connection_adapters/abstract/connection_specification.rb, line 269 269: def self.connected? 270: active_connections[active_connection_name] ? true : false 271: end
Returns the connection currently associated with the class. This can also be used to "borrow" the connection to do database work unrelated to any of the specific Active Records.
# File vendor/rails/activerecord/lib/active_record/connection_adapters/abstract/connection_specification.rb, line 73 73: def connection 74: if defined?(@active_connection_name) && (conn = active_connections[@active_connection_name]) 75: conn 76: else 77: # retrieve_connection sets the cache key. 78: conn = retrieve_connection 79: active_connections[@active_connection_name] = conn 80: end 81: end
Returns an array of column objects where the primary id, all columns ending in "_id" or "_count", and columns used for single table inheritance have been removed.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1163 1163: def content_columns 1164: @content_columns ||= columns.reject { |c| c.primary || c.name =~ /(_id|_count)$/ || c.name == inheritance_column } 1165: end
Returns the result of an SQL statement that should only include a COUNT(*) in the SELECT part. The use of this method should be restricted to complicated SQL queries that can‘t be executed using the ActiveRecord::Calculations class methods. Look into those before using this.
Product.count_by_sql "SELECT COUNT(*) FROM sales s, customers c WHERE s.customer_id = c.id"
# File vendor/rails/activerecord/lib/active_record/base.rb, line 801 801: def count_by_sql(sql) 802: sql = sanitize_conditions(sql) 803: connection.select_value(sql, "#{name} Count").to_i 804: end
Creates an object (or multiple objects) and saves it to the database, if validations pass. The resulting object is returned whether the object was saved successfully to the database or not.
The attributes parameter can be either be a Hash or an Array of Hashes. These Hashes describe the attributes on the objects that are to be created.
# Create a single new object User.create(:first_name => 'Jamie') # Create an Array of new objects User.create([{ :first_name => 'Jamie' }, { :first_name => 'Jeremy' }]) # Create a single object and pass it into a block to set other attributes. User.create(:first_name => 'Jamie') do |u| u.is_admin = false end # Creating an Array of new objects using a block, where the block is executed for each object: User.create([{ :first_name => 'Jamie' }, { :first_name => 'Jeremy' }]) do |u| u.is_admin = false end
# File vendor/rails/activerecord/lib/active_record/base.rb, line 634 634: def create(attributes = nil, &block) 635: if attributes.is_a?(Array) 636: attributes.collect { |attr| create(attr, &block) } 637: else 638: object = new(attributes) 639: yield(object) if block_given? 640: object.save 641: object 642: end 643: end
Decrement a number field by one, usually representing a count.
This works the same as increment_counter but reduces the column value by 1 instead of increasing it.
# Decrement the post_count column for the record with an id of 5 DiscussionBoard.decrement_counter(:post_count, 5)
# File vendor/rails/activerecord/lib/active_record/base.rb, line 868 868: def decrement_counter(counter_name, id) 869: update_counters(id, counter_name => -1) 870: end
Delete an object (or multiple objects) where the id given matches the primary_key. A SQL DELETE command is executed on the database which means that no callbacks are fired off running this. This is an efficient method of deleting records that don‘t need cleaning up after or other actions to be taken.
Objects are not instantiated with this method.
# Delete a single object Todo.delete(1) # Delete multiple objects todos = [1,2,3] Todo.delete(todos)
# File vendor/rails/activerecord/lib/active_record/base.rb, line 690 690: def delete(id) 691: delete_all([ "#{connection.quote_column_name(primary_key)} IN (?)", id ]) 692: end
Deletes the records matching conditions without instantiating the records first, and hence not calling the destroy method and invoking callbacks. This is a single SQL query, much more efficient than destroy_all.
Post.delete_all "person_id = 5 AND (category = 'Something' OR category = 'Else')"
This deletes the affected posts all at once with a single DELETE query. If you need to destroy dependent associations or call your before_ or after_destroy callbacks, use the destroy_all method instead.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 784 784: def delete_all(conditions = nil) 785: sql = "DELETE FROM #{quoted_table_name} " 786: add_conditions!(sql, conditions, scope(:find)) 787: connection.delete(sql, "#{name} Delete all") 788: end
True if this isn‘t a concrete subclass needing a STI type condition.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1199 1199: def descends_from_active_record? 1200: if superclass.abstract_class? 1201: superclass.descends_from_active_record? 1202: else 1203: superclass == Base || !columns_hash.include?(inheritance_column) 1204: end 1205: end
Destroy an object (or multiple objects) that has the given id, the object is instantiated first, therefore all callbacks and filters are fired off before the object is deleted. This method is less efficient than ActiveRecord#delete but allows cleanup methods and other actions to be run.
This essentially finds the object (or multiple objects) with the given id, creates a new object from the attributes, and then calls destroy on it.
# Destroy a single object Todo.destroy(1) # Destroy multiple objects todos = [1,2,3] Todo.destroy(todos)
# File vendor/rails/activerecord/lib/active_record/base.rb, line 713 713: def destroy(id) 714: if id.is_a?(Array) 715: id.map { |one_id| destroy(one_id) } 716: else 717: find(id).destroy 718: end 719: end
Destroys the records matching conditions by instantiating each record and calling the destroy method. This means at least 2*N database queries to destroy N records, so avoid destroy_all if you are deleting many records. If you want to simply delete records without worrying about dependent associations or callbacks, use the much faster delete_all method instead.
Person.destroy_all "last_login < '2004-04-04'"
This loads and destroys each person one by one, including its dependent associations and before_ and after_destroy callbacks.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 766 766: def destroy_all(conditions = nil) 767: find(:all, :conditions => conditions).each { |object| object.destroy } 768: end
Establishes the connection to the database. Accepts a hash as input where the :adapter key must be specified with the name of a database adapter (in lower-case) example for regular databases (MySQL, Postgresql, etc):
ActiveRecord::Base.establish_connection( :adapter => "mysql", :host => "localhost", :username => "myuser", :password => "mypass", :database => "somedatabase" )
Example for SQLite database:
ActiveRecord::Base.establish_connection( :adapter => "sqlite", :database => "path/to/dbfile" )
Also accepts keys as strings (for parsing from YAML for example):
ActiveRecord::Base.establish_connection( "adapter" => "sqlite", "database" => "path/to/dbfile" )
The exceptions AdapterNotSpecified, AdapterNotFound and ArgumentError may be returned on an error.
# File vendor/rails/activerecord/lib/active_record/connection_adapters/abstract/connection_specification.rb, line 205 205: def self.establish_connection(spec = nil) 206: case spec 207: when nil 208: raise AdapterNotSpecified unless defined? RAILS_ENV 209: establish_connection(RAILS_ENV) 210: when ConnectionSpecification 211: clear_active_connection_name 212: @active_connection_name = name 213: @@defined_connections[name] = spec 214: when Symbol, String 215: if configuration = configurations[spec.to_s] 216: establish_connection(configuration) 217: else 218: raise AdapterNotSpecified, "#{spec} database is not configured" 219: end 220: else 221: spec = spec.symbolize_keys 222: unless spec.key?(:adapter) then raise AdapterNotSpecified, "database configuration does not specify adapter" end 223: 224: begin 225: require 'rubygems' 226: gem "activerecord-#{spec[:adapter]}-adapter" 227: require "active_record/connection_adapters/#{spec[:adapter]}_adapter" 228: rescue LoadError 229: begin 230: require "active_record/connection_adapters/#{spec[:adapter]}_adapter" 231: rescue LoadError 232: raise "Please install the #{spec[:adapter]} adapter: `gem install activerecord-#{spec[:adapter]}-adapter` (#{$!})" 233: end 234: end 235: 236: adapter_method = "#{spec[:adapter]}_connection" 237: if !respond_to?(adapter_method) 238: raise AdapterNotFound, "database configuration specifies nonexistent #{spec[:adapter]} adapter" 239: end 240: 241: remove_connection 242: establish_connection(ConnectionSpecification.new(spec, adapter_method)) 243: end 244: end
Checks whether a record exists in the database that matches conditions given. These conditions can either be a single integer representing a primary key id to be found, or a condition to be matched like using ActiveRecord#find.
The id_or_conditions parameter can be an Integer or a String if you want to search the primary key column of the table for a matching id, or if you‘re looking to match against a condition you can use an Array or a Hash.
Possible gotcha: You can‘t pass in a condition as a string e.g. "name = ‘Jamie’", this would be sanitized and then queried against the primary key column as "id = ‘name = \’Jamie"
Person.exists?(5) Person.exists?('5') Person.exists?(:name => "David") Person.exists?(['name LIKE ?', "%#{query}%"])
# File vendor/rails/activerecord/lib/active_record/base.rb, line 601 601: def exists?(id_or_conditions) 602: connection.select_all( 603: construct_finder_sql( 604: :select => "#{quoted_table_name}.#{primary_key}", 605: :conditions => expand_id_conditions(id_or_conditions), 606: :limit => 1 607: ), 608: "#{name} Exists" 609: ).size > 0 610: end
Find operates with four different retrieval approaches:
All approaches accept an options hash as their last parameter.
# find by id Person.find(1) # returns the object for ID = 1 Person.find(1, 2, 6) # returns an array for objects with IDs in (1, 2, 6) Person.find([7, 17]) # returns an array for objects with IDs in (7, 17) Person.find([1]) # returns an array for the object with ID = 1 Person.find(1, :conditions => "administrator = 1", :order => "created_on DESC")
Note that returned records may not be in the same order as the ids you provide since database rows are unordered. Give an explicit :order to ensure the results are sorted.
# find first Person.find(:first) # returns the first object fetched by SELECT * FROM people Person.find(:first, :conditions => [ "user_name = ?", user_name]) Person.find(:first, :order => "created_on DESC", :offset => 5) # find last Person.find(:last) # returns the last object fetched by SELECT * FROM people Person.find(:last, :conditions => [ "user_name = ?", user_name]) Person.find(:last, :order => "created_on DESC", :offset => 5) # find all Person.find(:all) # returns an array of objects for all the rows fetched by SELECT * FROM people Person.find(:all, :conditions => [ "category IN (?)", categories], :limit => 50) Person.find(:all, :conditions => { :friends => ["Bob", "Steve", "Fred"] } Person.find(:all, :offset => 10, :limit => 10) Person.find(:all, :include => [ :account, :friends ]) Person.find(:all, :group => "category")
Example for find with a lock: Imagine two concurrent transactions: each will read person.visits == 2, add 1 to it, and save, resulting in two saves of person.visits = 3. By locking the row, the second transaction has to wait until the first is finished; we get the expected person.visits == 4.
Person.transaction do person = Person.find(1, :lock => true) person.visits += 1 person.save! end
# File vendor/rails/activerecord/lib/active_record/base.rb, line 528 528: def find(*args) 529: options = args.extract_options! 530: validate_find_options(options) 531: set_readonly_option!(options) 532: 533: case args.first 534: when :first then find_initial(options) 535: when :last then find_last(options) 536: when :all then find_every(options) 537: else find_from_ids(args, options) 538: end 539: end
Executes a custom SQL query against your database and returns all the results. The results will be returned as an array with columns requested encapsulated as attributes of the model you call this method from. If you call +Product.find_by_sql+ then the results will be returned in a Product object with the attributes you specified in the SQL query.
If you call a complicated SQL query which spans multiple tables the columns specified by the SELECT will be attributes of the model, whether or not they are columns of the corresponding table.
The sql parameter is a full SQL query as a string. It will be called as is, there will be no database agnostic conversions performed. This should be a last resort because using, for example, MySQL specific terms will lock you to using that particular database engine or require you to change your call if you switch engines
# A simple SQL query spanning multiple tables Post.find_by_sql "SELECT p.title, c.author FROM posts p, comments c WHERE p.id = c.post_id" > [#<Post:0x36bff9c @attributes={"title"=>"Ruby Meetup", "first_name"=>"Quentin"}>, ...] # You can use the same string replacement techniques as you can with ActiveRecord#find Post.find_by_sql ["SELECT title FROM posts WHERE author = ? AND created > ?", author_id, start_date] > [#<Post:0x36bff9c @attributes={"first_name"=>"The Cheap Man Buys Twice"}>, ...]
# File vendor/rails/activerecord/lib/active_record/base.rb, line 581 581: def find_by_sql(sql) 582: connection.select_all(sanitize_sql(sql), "#{name} Load").collect! { |record| instantiate(record) } 583: end
Increment a number field by one, usually representing a count.
This is used for caching aggregate values, so that they don‘t need to be computed every time. For example, a DiscussionBoard may cache post_count and comment_count otherwise every time the board is shown it would have to run an SQL query to find how many posts and comments there are.
# Increment the post_count column for the record with an id of 5 DiscussionBoard.increment_counter(:post_count, 5)
# File vendor/rails/activerecord/lib/active_record/base.rb, line 851 851: def increment_counter(counter_name, id) 852: update_counters(id, counter_name => 1) 853: end
Defines the column name for use with single table inheritance — can be set in subclasses like so: self.inheritance_column = "type_id"
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1057 1057: def inheritance_column 1058: @inheritance_column ||= "type".freeze 1059: end
Returns a string like ‘Post id:integer, title:string, body:text‘
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1213 1213: def inspect 1214: if self == Base 1215: super 1216: elsif abstract_class? 1217: "#{super}(abstract)" 1218: elsif table_exists? 1219: attr_list = columns.map { |c| "#{c.name}: #{c.type}" } * ', ' 1220: "#{super}(#{attr_list})" 1221: else 1222: "#{super}(Table doesn't exist)" 1223: end 1224: end
New objects can be instantiated as either empty (pass no construction parameter) or pre-set with attributes but not yet saved (pass a hash with key names matching the associated table column names). In both instances, valid attribute keys are determined by the column names of the associated table — hence you can‘t have attributes that aren‘t part of the table columns.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2125 2125: def initialize(attributes = nil) 2126: @attributes = attributes_from_column_definition 2127: @attributes_cache = {} 2128: @new_record = true 2129: ensure_proper_type 2130: self.attributes = attributes unless attributes.nil? 2131: self.class.send(:scope, :create).each { |att,value| self.send("#{att}=", value) } if self.class.send(:scoped?, :create) 2132: result = yield self if block_given? 2133: callback(:after_initialize) if respond_to_without_attributes?(:after_initialize) 2134: result 2135: end
Defines the primary key field — can be overridden in subclasses. Overwriting will negate any effect of the primary_key_prefix_type setting, though.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1034 1034: def primary_key 1035: reset_primary_key 1036: end
Returns an array of all the attributes that have been specified as readonly.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 945 945: def readonly_attributes 946: read_inheritable_attribute("attr_readonly") 947: end
Remove the connection for this class. This will close the active connection and the defined connection (if they exist). The result can be used as an argument for establish_connection, for easily re-establishing the connection.
# File vendor/rails/activerecord/lib/active_record/connection_adapters/abstract/connection_specification.rb, line 277 277: def self.remove_connection(klass=self) 278: spec = @@defined_connections[klass.name] 279: konn = active_connections[klass.name] 280: @@defined_connections.delete_if { |key, value| value == spec } 281: active_connections.delete_if { |key, value| value == konn } 282: konn.disconnect! if konn 283: spec.config if spec 284: end
# File vendor/rails/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb, line 47 47: def self.require_mysql 48: # Include the MySQL driver if one hasn't already been loaded 49: unless defined? Mysql 50: begin 51: require_library_or_gem 'mysql' 52: rescue LoadError => cannot_require_mysql 53: # Use the bundled Ruby/MySQL driver if no driver is already in place 54: begin 55: ActiveRecord::Base.logger.info( 56: "WARNING: You're using the Ruby-based MySQL library that ships with Rails. This library is not suited for production. " + 57: "Please install the C-based MySQL library instead (gem install mysql)." 58: ) if ActiveRecord::Base.logger 59: 60: require 'active_record/vendor/mysql' 61: rescue LoadError 62: raise cannot_require_mysql 63: end 64: end 65: end 66: 67: # Define Mysql::Result.all_hashes 68: MysqlCompat.define_all_hashes_method! 69: end
Resets all the cached information about columns, which will cause them to be reloaded on the next request.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1182 1182: def reset_column_information 1183: generated_methods.each { |name| undef_method(name) } 1184: @column_names = @columns = @columns_hash = @content_columns = @dynamic_methods_hash = @generated_methods = @inheritance_column = nil 1185: end
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1289 1289: def respond_to?(method_id, include_private = false) 1290: if match = matches_dynamic_finder?(method_id) || matches_dynamic_finder_with_initialize_or_create?(method_id) 1291: return true if all_attributes_exists?(extract_attribute_names_from_match(match)) 1292: end 1293: super 1294: end
If you have an attribute that needs to be saved to the database as an object, and retrieved as the same object, then specify the name of that attribute using this method and it will be handled automatically. The serialization is done through YAML. If class_name is specified, the serialized object must be of that class on retrieval or SerializationTypeMismatch will be raised.
# Serialize a preferences attribute class User serialize :preferences end
# File vendor/rails/activerecord/lib/active_record/base.rb, line 964 964: def serialize(attr_name, class_name = Object) 965: serialized_attributes[attr_name.to_s] = class_name 966: end
Returns a hash of all the attributes that have been specified for serialization as keys and their class restriction as values.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 969 969: def serialized_attributes 970: read_inheritable_attribute("attr_serialized") or write_inheritable_attribute("attr_serialized", {}) 971: end
Sets the name of the inheritance column to use to the given value, or (if the value # is nil or false) to the value returned by the given block.
class Project < ActiveRecord::Base set_inheritance_column do original_inheritance_column + "_id" end end
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1105 1105: def set_inheritance_column(value = nil, &block) 1106: define_attr_method :inheritance_column, value, &block 1107: end
Sets the name of the primary key column to use to the given value, or (if the value is nil or false) to the value returned by the given block.
class Project < ActiveRecord::Base set_primary_key "sysid" end
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1091 1091: def set_primary_key(value = nil, &block) 1092: define_attr_method :primary_key, value, &block 1093: end
Sets the name of the sequence to use when generating ids to the given value, or (if the value is nil or false) to the value returned by the given block. This is required for Oracle and is useful for any database which relies on sequences for primary key generation.
If a sequence name is not explicitly set when using Oracle or Firebird, it will default to the commonly used pattern of: #{table_name}_seq
If a sequence name is not explicitly set when using PostgreSQL, it will discover the sequence corresponding to your primary key for you.
class Project < ActiveRecord::Base set_sequence_name "projectseq" # default would have been "project_seq" end
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1124 1124: def set_sequence_name(value = nil, &block) 1125: define_attr_method :sequence_name, value, &block 1126: end
Sets the table name to use to the given value, or (if the value is nil or false) to the value returned by the given block.
class Project < ActiveRecord::Base set_table_name "project" end
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1079 1079: def set_table_name(value = nil, &block) 1080: define_attr_method :table_name, value, &block 1081: end
Silences the logger for the duration of the block.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1261 1261: def silence 1262: old_logger_level, logger.level = logger.level, Logger::ERROR if logger 1263: yield 1264: ensure 1265: logger.level = old_logger_level if logger 1266: end
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1296 1296: def sti_name 1297: store_full_sti_class ? name : name.demodulize 1298: end
Indicates whether the table associated with this class exists
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1138 1138: def table_exists? 1139: connection.table_exists?(table_name) 1140: end
Guesses the table name (in forced lower-case) based on the name of the class in the inheritance hierarchy descending directly from ActiveRecord::Base. So if the hierarchy looks like: Reply < Message < ActiveRecord::Base, then Message is used to guess the table name even when called on Reply. The rules used to do the guess are handled by the Inflector class in Active Support, which knows almost all common English inflections. You can add new inflections in config/initializers/inflections.rb.
Nested classes are given table names prefixed by the singular form of the parent‘s table name. Enclosing modules are not considered.
class Invoice < ActiveRecord::Base; end; file class table_name invoice.rb Invoice invoices class Invoice < ActiveRecord::Base; class Lineitem < ActiveRecord::Base; end; end; file class table_name invoice.rb Invoice::Lineitem invoice_lineitems module Invoice; class Lineitem < ActiveRecord::Base; end; end; file class table_name invoice/lineitem.rb Invoice::Lineitem lineitems
Additionally, the class-level table_name_prefix is prepended and the table_name_suffix is appended. So if you have "myapp_" as a prefix, the table name guess for an Invoice class becomes "myapp_invoices". Invoice::Lineitem becomes "myapp_invoice_lineitems".
You can also overwrite this class method to allow for unguessable links, such as a Mouse class with a link to a "mice" table. Example:
class Mouse < ActiveRecord::Base set_table_name "mice" end
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1007 1007: def table_name 1008: reset_table_name 1009: end
Updates an object (or multiple objects) and saves it to the database, if validations pass. The resulting object is returned whether the object was saved successfully to the database or not.
# Updating one record: Person.update(15, { :user_name => 'Samuel', :group => 'expert' }) # Updating multiple records: people = { 1 => { "first_name" => "David" }, 2 => { "first_name" => "Jeremy" } } Person.update(people.keys, people.values)
# File vendor/rails/activerecord/lib/active_record/base.rb, line 661 661: def update(id, attributes) 662: if id.is_a?(Array) 663: idx = -1 664: id.collect { |one_id| idx += 1; update(one_id, attributes[idx]) } 665: else 666: object = find(id) 667: object.update_attributes(attributes) 668: object 669: end 670: end
Updates all records with details given if they match a set of conditions supplied, limits and order can also be supplied.
# Update all billing objects with the 3 different attributes given Billing.update_all( "category = 'authorized', approved = 1, author = 'David'" ) # Update records that match our conditions Billing.update_all( "author = 'David'", "title LIKE '%Rails%'" ) # Update records that match our conditions but limit it to 5 ordered by date Billing.update_all( "author = 'David'", "title LIKE '%Rails%'", :order => 'created_at', :limit => 5 )
# File vendor/rails/activerecord/lib/active_record/base.rb, line 742 742: def update_all(updates, conditions = nil, options = {}) 743: sql = "UPDATE #{quoted_table_name} SET #{sanitize_sql_for_assignment(updates)} " 744: scope = scope(:find) 745: add_conditions!(sql, conditions, scope) 746: add_order!(sql, options[:order], nil) 747: add_limit!(sql, options, nil) 748: connection.update(sql, "#{name} Update") 749: end
A generic "counter updater" implementation, intended primarily to be used by increment_counter and decrement_counter, but which may also be useful on its own. It simply does a direct SQL update for the record with the given ID, altering the given hash of counters by the amount given by the corresponding value:
# For the Post with id of 5, decrement the comment_count by 1, and # increment the action_count by 1 Post.update_counters 5, :comment_count => -1, :action_count => 1 # Executes the following SQL: # UPDATE posts # SET comment_count = comment_count - 1, # action_count = action_count + 1 # WHERE id = 5
# File vendor/rails/activerecord/lib/active_record/base.rb, line 828 828: def update_counters(id, counters) 829: updates = counters.inject([]) { |list, (counter_name, increment)| 830: sign = increment < 0 ? "-" : "+" 831: list << "#{connection.quote_column_name(counter_name)} = #{connection.quote_column_name(counter_name)} #{sign} #{increment.abs}" 832: }.join(", ") 833: update_all(updates, "#{connection.quote_column_name(primary_key)} = #{quote_value(id)}") 834: end
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1956 1956: def aggregate_mapping(reflection) 1957: mapping = reflection.options[:mapping] || [reflection.name, reflection.name] 1958: mapping.first.is_a?(Array) ? mapping : [mapping] 1959: end
Returns the class descending directly from Active Record in the inheritance hierarchy.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1914 1914: def class_of_active_record_descendant(klass) 1915: if klass.superclass == Base || klass.superclass.abstract_class? 1916: klass 1917: elsif klass.superclass.nil? 1918: raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord" 1919: else 1920: class_of_active_record_descendant(klass.superclass) 1921: end 1922: end
Returns the class type of the record using the current module as a prefix. So descendents of MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1904 1904: def compute_type(type_name) 1905: modularized_name = type_name_with_module(type_name) 1906: begin 1907: class_eval(modularized_name, __FILE__, __LINE__) 1908: rescue NameError 1909: class_eval(type_name, __FILE__, __LINE__) 1910: end 1911: end
Accepts a hash of SQL conditions and replaces those attributes that correspond to a composed_of relationship with their expanded aggregate attribute values. Given:
class Person < ActiveRecord::Base composed_of :address, :class_name => "Address", :mapping => [%w(address_street street), %w(address_city city)] end
Then:
{ :address => Address.new("813 abc st.", "chicago") } # => { :address_street => "813 abc st.", :address_city => "chicago" }
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1972 1972: def expand_hash_conditions_for_aggregates(attrs) 1973: expanded_attrs = {} 1974: attrs.each do |attr, value| 1975: unless (aggregation = reflect_on_aggregation(attr.to_sym)).nil? 1976: mapping = aggregate_mapping(aggregation) 1977: mapping.each do |field_attr, aggregate_attr| 1978: if mapping.size == 1 && !value.respond_to?(aggregate_attr) 1979: expanded_attrs[field_attr] = value 1980: else 1981: expanded_attrs[field_attr] = value.send(aggregate_attr) 1982: end 1983: end 1984: else 1985: expanded_attrs[attr] = value 1986: end 1987: end 1988: expanded_attrs 1989: end
Accepts an array of conditions. The array has each value sanitized and interpolated into the SQL statement.
["name='%s' and group_id='%s'", "foo'bar", 4] returns "name='foo''bar' and group_id='4'"
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2036 2036: def sanitize_sql_array(ary) 2037: statement, *values = ary 2038: if values.first.is_a?(Hash) and statement =~ /:\w+/ 2039: replace_named_bind_variables(statement, values.first) 2040: elsif statement.include?('?') 2041: replace_bind_variables(statement, values) 2042: else 2043: statement % values.collect { |value| connection.quote_string(value.to_s) } 2044: end 2045: end
Accepts an array, hash, or string of SQL conditions and sanitizes them into a valid SQL fragment for a SET clause.
{ :name => nil, :group_id => 4 } returns "name = NULL , group_id='4'"
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1948 1948: def sanitize_sql_for_assignment(assignments) 1949: case assignments 1950: when Array; sanitize_sql_array(assignments) 1951: when Hash; sanitize_sql_hash_for_assignment(assignments) 1952: else assignments 1953: end 1954: end
Accepts an array, hash, or string of SQL conditions and sanitizes them into a valid SQL fragment for a WHERE clause.
["name='%s' and group_id='%s'", "foo'bar", 4] returns "name='foo''bar' and group_id='4'" { :name => "foo'bar", :group_id => 4 } returns "name='foo''bar' and group_id='4'" "name='foo''bar' and group_id='4'" returns "name='foo''bar' and group_id='4'"
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1934 1934: def sanitize_sql_for_conditions(condition) 1935: return nil if condition.blank? 1936: 1937: case condition 1938: when Array; sanitize_sql_array(condition) 1939: when Hash; sanitize_sql_hash_for_conditions(condition) 1940: else condition 1941: end 1942: end
Sanitizes a hash of attribute/value pairs into SQL conditions for a SET clause.
{ :status => nil, :group_id => 1 } # => "status = NULL , group_id = 1"
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2027 2027: def sanitize_sql_hash_for_assignment(attrs) 2028: attrs.map do |attr, value| 2029: "#{connection.quote_column_name(attr)} = #{quote_bound_value(value)}" 2030: end.join(', ') 2031: end
Sanitizes a hash of attribute/value pairs into SQL conditions for a WHERE clause.
{ :name => "foo'bar", :group_id => 4 } # => "name='foo''bar' and group_id= 4" { :status => nil, :group_id => [1,2,3] } # => "status IS NULL and group_id IN (1,2,3)" { :age => 13..18 } # => "age BETWEEN 13 AND 18" { 'other_records.id' => 7 } # => "`other_records`.`id` = 7"
And for value objects on a composed_of relationship:
{ :address => Address.new("123 abc st.", "chicago") } # => "address_street='123 abc st.' and address_city='chicago'"
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2003 2003: def sanitize_sql_hash_for_conditions(attrs) 2004: attrs = expand_hash_conditions_for_aggregates(attrs) 2005: 2006: conditions = attrs.map do |attr, value| 2007: attr = attr.to_s 2008: 2009: # Extract table name from qualified attribute names. 2010: if attr.include?('.') 2011: table_name, attr = attr.split('.', 2) 2012: table_name = connection.quote_table_name(table_name) 2013: else 2014: table_name = quoted_table_name 2015: end 2016: 2017: "#{table_name}.#{connection.quote_column_name(attr)} #{attribute_condition(value)}" 2018: end.join(' AND ') 2019: 2020: replace_bind_variables(conditions, expand_range_bind_variables(attrs.values)) 2021: end
Works like with_scope, but discards any nested properties.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1859 1859: def with_exclusive_scope(method_scoping = {}, &block) 1860: with_scope(method_scoping, :overwrite, &block) 1861: end
Scope parameters to method calls within the block. Takes a hash of method_name => parameters hash. method_name may be :find or :create. :find parameters may include the :conditions, :joins, :include, :offset, :limit, and :readonly options. :create parameters are an attributes hash.
class Article < ActiveRecord::Base def self.create_with_scope with_scope(:find => { :conditions => "blog_id = 1" }, :create => { :blog_id => 1 }) do find(1) # => SELECT * from articles WHERE blog_id = 1 AND id = 1 a = create(1) a.blog_id # => 1 end end end
In nested scopings, all previous parameters are overwritten by the innermost rule, with the exception of :conditions and :include options in :find, which are merged.
class Article < ActiveRecord::Base def self.find_with_scope with_scope(:find => { :conditions => "blog_id = 1", :limit => 1 }, :create => { :blog_id => 1 }) do with_scope(:find => { :limit => 10 }) find(:all) # => SELECT * from articles WHERE blog_id = 1 LIMIT 10 end with_scope(:find => { :conditions => "author_id = 3" }) find(:all) # => SELECT * from articles WHERE blog_id = 1 AND author_id = 3 LIMIT 1 end end end end
You can ignore any previous scopings by using the with_exclusive_scope method.
class Article < ActiveRecord::Base def self.find_with_exclusive_scope with_scope(:find => { :conditions => "blog_id = 1", :limit => 1 }) do with_exclusive_scope(:find => { :limit => 10 }) find(:all) # => SELECT * from articles LIMIT 10 end end end end
# File vendor/rails/activerecord/lib/active_record/base.rb, line 1807 1807: def with_scope(method_scoping = {}, action = :merge, &block) 1808: method_scoping = method_scoping.method_scoping if method_scoping.respond_to?(:method_scoping) 1809: 1810: # Dup first and second level of hash (method and params). 1811: method_scoping = method_scoping.inject({}) do |hash, (method, params)| 1812: hash[method] = (params == true) ? params : params.dup 1813: hash 1814: end 1815: 1816: method_scoping.assert_valid_keys([ :find, :create ]) 1817: 1818: if f = method_scoping[:find] 1819: f.assert_valid_keys(VALID_FIND_OPTIONS) 1820: set_readonly_option! f 1821: end 1822: 1823: # Merge scopings 1824: if action == :merge && current_scoped_methods 1825: method_scoping = current_scoped_methods.inject(method_scoping) do |hash, (method, params)| 1826: case hash[method] 1827: when Hash 1828: if method == :find 1829: (hash[method].keys + params.keys).uniq.each do |key| 1830: merge = hash[method][key] && params[key] # merge if both scopes have the same key 1831: if key == :conditions && merge 1832: hash[method][key] = merge_conditions(params[key], hash[method][key]) 1833: elsif key == :include && merge 1834: hash[method][key] = merge_includes(hash[method][key], params[key]).uniq 1835: else 1836: hash[method][key] = hash[method][key] || params[key] 1837: end 1838: end 1839: else 1840: hash[method] = params.merge(hash[method]) 1841: end 1842: else 1843: hash[method] = params 1844: end 1845: hash 1846: end 1847: end 1848: 1849: self.scoped_methods << method_scoping 1850: 1851: begin 1852: yield 1853: ensure 1854: self.scoped_methods.pop 1855: end 1856: end
Returns true if the comparison_object is the same object, or is of the same type and has the same id.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2421 2421: def ==(comparison_object) 2422: comparison_object.equal?(self) || 2423: (comparison_object.instance_of?(self.class) && 2424: comparison_object.id == id && 2425: !comparison_object.new_record?) 2426: end
Returns the value of the attribute identified by attr_name after it has been typecast (for example, "2004-12-12" in a data column is cast to a date object, like Date.new(2004, 12, 12)). (Alias for the protected read_attribute method).
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2338 2338: def [](attr_name) 2339: read_attribute(attr_name) 2340: end
Updates the attribute identified by attr_name with the specified value. (Alias for the protected write_attribute method).
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2344 2344: def []=(attr_name, value) 2345: write_attribute(attr_name, value) 2346: end
Format attributes nicely for inspect.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2386 2386: def attribute_for_inspect(attr_name) 2387: value = read_attribute(attr_name) 2388: 2389: if value.is_a?(String) && value.length > 50 2390: "#{value[0..50]}...".inspect 2391: elsif value.is_a?(Date) || value.is_a?(Time) 2392: %("#{value.to_s(:db)}") 2393: else 2394: value.inspect 2395: end 2396: end
Returns an array of names for the attributes available on this object sorted alphabetically.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2411 2411: def attribute_names 2412: @attributes.keys.sort 2413: end
Returns true if the specified attribute has been set by the user or by a database load and is neither nil nor empty? (the latter only applies to objects that respond to empty?, most notably Strings).
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2400 2400: def attribute_present?(attribute) 2401: value = read_attribute(attribute) 2402: !value.blank? 2403: end
Returns a hash of all the attributes with their names as keys and the values of the attributes as values.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2370 2370: def attributes 2371: self.attribute_names.inject({}) do |attrs, name| 2372: attrs[name] = read_attribute(name) 2373: attrs 2374: end 2375: end
Allows you to set all the attributes at once by passing in a hash with keys matching the attribute names (which again matches the column names). Sensitive attributes can be protected from this form of mass-assignment by using the attr_protected macro. Or you can alternatively specify which attributes can be accessed with the attr_accessible macro. Then all the attributes not included in that won‘t be allowed to be mass-assigned.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2353 2353: def attributes=(new_attributes, guard_protected_attributes = true) 2354: return if new_attributes.nil? 2355: attributes = new_attributes.dup 2356: attributes.stringify_keys! 2357: 2358: multi_parameter_attributes = [] 2359: attributes = remove_attributes_protected_from_mass_assignment(attributes) if guard_protected_attributes 2360: 2361: attributes.each do |k, v| 2362: k.include?("(") ? multi_parameter_attributes << [ k, v ] : send(k + "=", v) 2363: end 2364: 2365: assign_multiparameter_attributes(multi_parameter_attributes) 2366: end
Returns a hash of attributes before typecasting and deserialization.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2378 2378: def attributes_before_type_cast 2379: self.attribute_names.inject({}) do |attrs, name| 2380: attrs[name] = read_attribute_before_type_cast(name) 2381: attrs 2382: end 2383: end
Returns an instance of the specified klass with the attributes of the current record. This is mostly useful in relation to single-table inheritance structures where you want a subclass to appear as the superclass. This can be used along with record identification in Action Pack to allow, say, Client < Company to do something like render :partial => @client.becomes(Company) to render that instance using the companies/company partial instead of clients/client.
Note: The new instance will share a link to the same attributes as the original class. So any change to the attributes in either instance will affect the other.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2243 2243: def becomes(klass) 2244: returning klass.new do |became| 2245: became.instance_variable_set("@attributes", @attributes) 2246: became.instance_variable_set("@attributes_cache", @attributes_cache) 2247: became.instance_variable_set("@new_record", new_record?) 2248: end 2249: end
Returns a cache key that can be used to identify this record.
Product.new.cache_key # => "products/new" Product.find(5).cache_key # => "products/5" (updated_at not available) Person.find(5).cache_key # => "people/5-20071224150000" (updated_at available)
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2162 2162: def cache_key 2163: case 2164: when new_record? 2165: "#{self.class.name.tableize}/new" 2166: when self[:updated_at] 2167: "#{self.class.name.tableize}/#{id}-#{updated_at.to_s(:number)}" 2168: else 2169: "#{self.class.name.tableize}/#{id}" 2170: end 2171: end
Returns a clone of the record that hasn‘t been assigned an id yet and is treated as a new record. Note that this is a "shallow" clone: it copies the object‘s attributes only, not its associations. The extent of a "deep" clone is application-specific and is therefore left to the application to implement according to its need.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2228 2228: def clone 2229: attrs = clone_attributes(:read_attribute_before_type_cast) 2230: attrs.delete(self.class.primary_key) 2231: record = self.class.new 2232: record.send :instance_variable_set, '@attributes', attrs 2233: record 2234: end
Returns the column object for the named attribute.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2416 2416: def column_for_attribute(name) 2417: self.class.columns_hash[name.to_s] 2418: end
Returns the connection currently associated with the class. This can also be used to "borrow" the connection to do database work that isn‘t easily done without going straight to SQL.
# File vendor/rails/activerecord/lib/active_record/connection_adapters/abstract/connection_specification.rb, line 173 173: def connection 174: self.class.connection 175: end
Initializes attribute to zero if nil and subtracts the value passed as by (default is 1). The decrement is performed directly on the underlying attribute, no setter is invoked. Only makes sense for number-based attributes. Returns self.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2292 2292: def decrement(attribute, by = 1) 2293: self[attribute] ||= 0 2294: self[attribute] -= by 2295: self 2296: end
Wrapper around decrement that saves the record. This method differs from its non-bang version in that it passes through the attribute setter. Saving is not subjected to validation checks. Returns true if the record could be saved.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2302 2302: def decrement!(attribute, by = 1) 2303: decrement(attribute, by).update_attribute(attribute, self[attribute]) 2304: end
Deletes the record in the database and freezes this instance to reflect that no changes should be made (since they can‘t be persisted).

# File vendor/rails/activerecord/lib/active_record/base.rb, line 2440 2440: def freeze 2441: @attributes.freeze; self 2442: end
Returns true if the attributes hash has been frozen.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2445 2445: def frozen? 2446: @attributes.frozen? 2447: end
Returns true if the given attribute is in the attributes hash
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2406 2406: def has_attribute?(attr_name) 2407: @attributes.has_key?(attr_name.to_s) 2408: end
Delegates to id in order to allow two records of the same type and id to work with something like:
[ Person.find(1), Person.find(2), Person.find(3) ] & [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ]
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2435 2435: def hash 2436: id.hash 2437: end
A model instance‘s primary key is always available as model.id whether you name it the default ‘id’ or set it to something else.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2139 2139: def id 2140: attr_name = self.class.primary_key 2141: column = column_for_attribute(attr_name) 2142: 2143: self.class.send(:define_read_method, :id, attr_name, column) 2144: # now that the method exists, call it 2145: self.send attr_name.to_sym 2146: 2147: end
Sets the primary ID.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2182 2182: def id=(value) 2183: write_attribute(self.class.primary_key, value) 2184: end
Initializes attribute to zero if nil and adds the value passed as by (default is 1). The increment is performed directly on the underlying attribute, no setter is invoked. Only makes sense for number-based attributes. Returns self.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2275 2275: def increment(attribute, by = 1) 2276: self[attribute] ||= 0 2277: self[attribute] += by 2278: self 2279: end
Wrapper around increment that saves the record. This method differs from its non-bang version in that it passes through the attribute setter. Saving is not subjected to validation checks. Returns true if the record could be saved.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2285 2285: def increment!(attribute, by = 1) 2286: increment(attribute, by).update_attribute(attribute, self[attribute]) 2287: end
Returns the contents of the record as a nicely formatted string.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2461 2461: def inspect 2462: attributes_as_nice_string = self.class.column_names.collect { |name| 2463: if has_attribute?(name) || new_record? 2464: "#{name}: #{attribute_for_inspect(name)}" 2465: end 2466: }.compact.join(", ") 2467: "#<#{self.class} #{attributes_as_nice_string}>" 2468: end
Returns true if this object hasn‘t been saved yet — that is, a record for the object doesn‘t exist yet.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2187 2187: def new_record? 2188: defined?(@new_record) && @new_record 2189: end
Marks this record as read only.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2456 2456: def readonly! 2457: @readonly = true 2458: end
Returns true if the record is read only. Records loaded through joins with piggy-back attributes will be marked as read only since they cannot be saved.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2451 2451: def readonly? 2452: defined?(@readonly) && @readonly == true 2453: end
Reloads the attributes of this object from the database. The optional options argument is passed to find when reloading so you may do e.g. record.reload(:lock => true) to reload the same record with an exclusive row lock.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2327 2327: def reload(options = nil) 2328: clear_aggregation_cache 2329: clear_association_cache 2330: @attributes.update(self.class.find(self.id, options).instance_variable_get('@attributes')) 2331: @attributes_cache = {} 2332: self 2333: end
Note: If your model specifies any validations then the method declaration dynamically changes to:
save(perform_validation=true)
Calling save(false) saves the model without running validations. See ActiveRecord::Validations for more information.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2199 2199: def save 2200: create_or_update 2201: end
Attempts to save the record, but instead of just returning false if it couldn‘t happen, it raises a RecordNotSaved exception
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2205 2205: def save! 2206: create_or_update || raise(RecordNotSaved) 2207: end
Enables Active Record objects to be used as URL parameters in Action Pack automatically.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2150 2150: def to_param 2151: # We can't use alias_method here, because method 'id' optimizes itself on the fly. 2152: (id = self.id) ? id.to_s : nil # Be sure to stringify the id for routes 2153: end
Assigns to attribute the boolean opposite of attribute?. So if the predicate returns true the attribute will become false. This method toggles directly the underlying value without calling any setter. Returns self.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2310 2310: def toggle(attribute) 2311: self[attribute] = !send("#{attribute}?") 2312: self 2313: end
Wrapper around toggle that saves the record. This method differs from its non-bang version in that it passes through the attribute setter. Saving is not subjected to validation checks. Returns true if the record could be saved.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2319 2319: def toggle!(attribute) 2320: toggle(attribute).update_attribute(attribute, self[attribute]) 2321: end
Updates a single attribute and saves the record. This is especially useful for boolean flags on existing records. Note: This method is overwritten by the Validation module that‘ll make sure that updates made with this method aren‘t subjected to validation checks. Hence, attributes can be updated even if the full object isn‘t valid.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2254 2254: def update_attribute(name, value) 2255: send(name.to_s + '=', value) 2256: save 2257: end
Updates all the attributes from the passed-in Hash and saves the record. If the object is invalid, the saving will fail and false will be returned.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2261 2261: def update_attributes(attributes) 2262: self.attributes = attributes 2263: save 2264: end
Updates an object just like Base.update_attributes but calls save! instead of save so an exception is raised if the record is invalid.
# File vendor/rails/activerecord/lib/active_record/base.rb, line 2267 2267: def update_attributes!(attributes) 2268: self.attributes = attributes 2269: save! 2270: end


Join Weather Underground
- Choose real-time alerts for your city.
- Choose adding your webcam or personal weather station.
- You can delete your account at any time from your member settings.
The Weather Company needs your email to create your Weather Underground account.
Email:
Password:
Confirm New Password:
Sign up for free


1. Choose red and blue
Please choose a color on the left side.
2. Feelings
You haven't selected a color!
This is
Happy
Sad
Uncertain
Neutral
3. Results
Execute steps 1 and 2 first!
Results for


Brennin Young
Home
Portfolio
Contact
Portfolio
Hangman
RPG Game
Trivia Game
Rutgers Info Widget
Rock Paper Scissors
Copyright©


nape.util.Debug
- type
- class
- subclasses
- nape.util.BitmapDebug, nape.util.ShapeDebug
Debug class providing general utilities
Also serves as the base type for Debug draws.
Static Methods
- parameters
body
The body to create display Shape for.
- returns
- A flash/openfl||nme.display.Shape representing Body.
- throws
#
If body is null.
Instance Methods
- parameters
object
The object to draw.
- throws
#
If object is null or not of the expected Type.
- parameters
aabb
The AABB to draw.
colour
The colour to draw AABB with in RGB.
- throws
#
If AABB is null.
- parameters
position
The position of circle centre.
radius
The radius of the circle.
colour
The colour of circle in RGB.
- throws
#
If position is null or disposed of.
#
If radius is negative.
#
If transform is not equiorthogonal.
- parameters
start
The start point of curve.
control
The control point for curve.
end
The end point of curve.
colour
The colour of curve in RGB.
- throws
#
If any Vec2 argument is null or disposed of.
- parameters
position
The position of centre of circle.
radius
The radius of circle.
colour
The colour to draw circle with in RGB.
- throws
#
If position is null or disposed of.
#
If radius is negative.
#
If transform is not equiorthogonal.
- parameters
polygon
The polygon to draw.
colour
The colour to draw polygon with in RGB.
- throws
#
If polygon is null, or not of expected type.
#
If polygon contains disposed Vec2.
- parameters
p0
The first point in triangle.
p1
The second point in triangle.
p2
The third point in triangle.
colour
The colour to draw triangle with in RGB.
- throws
#
If any point argument is null or disposed of.
- parameters
start
The start point of line segment.
end
The end point of line segment.
colour
The colour of line in RGB.
- throws
#
If either start or end are null or disposed of.
- parameters
polygon
The polygon to draw.
colour
The colour to draw polygon with in RGB.
- throws
#
If polygon is null, or not of expected type.
#
If polygon contains disposed Vec2.
- parameters
start
The start point of spring.
end
The end point of spring.
colour
The colour of spring in RGB.
coils
The number of coils in spring. (default 3)
radius
The radius of spring. (default 3.0)
- throws
#
If start or end are either null or disposed of.
#
If number of coils is negative.


I'm a full stack software developer.
Love to problem solving, build website, web API and play with algorithm.
Very excited with javascript technologies.
Learn new things about javascript.
But i'm open to any technology that can solves all of my problem.


Dear Sir/Madam I made up my mind with trust to contact you for an urgent and very confidential business, knowing fully well that this letter may come to you as a surprise. I'm MISS Juliet johnson, Controller International Unit(Operations)Global Trust Bank London. I'm a native of Switzerland, but based here in London. In the course of our Last Annual Account's check, I discovered that a customer Mr. Michael Hammond made a Fixed Deposit valued at �800,000.00(Four Million Eight Hundred Thousand Pounds).In my further investigation,I discovered that he died on 6th September 2003 without making a WILL, did not also declare any Next of Kin or relations in all his official documents, including his Bank Deposit documents in this Bank. This sum of �800,000.00 is still in this Bank,no one has ever come forward to claim it. My proposal is that I will like you to stand in as the Next of Kin to Late Mr. Michael Hammond so that we can claim this funds. This is very simple as long I?m here to direct and provide you with every information required for this transaction.This Funds will be paid to you, for us to shared, the expences that will occur in this transaction will be taking of, if it will cost me much to settle my asisstant and others i dont mind,just to make sure this money didn't enter Banks account. No risk involved in this transaction as my position guarantees the successful execution of this transaction. Feel free to reply me back with my private email adress ,if you are interested. to claim this funds as Next Of Kin to Late Mr Michael Hammond, it is upon your response that I shall then provide you with more details and relevant information that will help us to go about this transaction. All I want from you is honesty and trust worthiness. Please observe utmost confidentiality, and be rest assured that this transaction would be most profitable for all of us. CONTACT ME WITH THIS PRIVATELY<EMAIL_ADDRESS>Regards. Miss. juliet johnson 97 Cromwell Road London,SW4DN U.K ______________________________________________ http://www.sentimente.ro Singur? Peste 180.000 utilizatori pentru tine!


Bootstrap
Hello, world!
Next Line
Email address
We'll never share your email with anyone else.
Password
Check me out
Submit


Projects
Search Engine
Museum-Related Information Search Engine
We created an East Asia museum related information search engine by using the data from three museums, and a web interface for searching, ranking and showing results.
(SI 650: Information Retrieval)
Sentiment Analysis
A Product Evaluation System Based on Sentiment Analysis of E-commerce Platform Comment Data
(SI 671: Data Mining: Methods & Applications)
Contextual Inquiry
Communicating Effectively with Global African Studies Community
We did researches and interviews to help our client The African Studies Center of the Michigan State University to improve the effectiveness of their communication channels.
(SI 501: Contextual Inquiry and consulting foundations)
Data Manipulation
Climate and Greenhouse Gases
In order to call on everyone to protect the environment, this project investigated the data of climate and greenhouse gas concentrations and demonstrated the greenhouse effect and environmental trend.
(SI 618: Data Manipulation and Analysis)
Explanatory Data Analysis
Analysis of Steam PC Games
Focusing on the Steam game data set, explanatory data analysis was done to have an insight of what made a PC game popular.
(SI 618: Data Manipulation and Analysis)
Bayesian Analysis
Locating Jiuling in the Forbidden Forest
We tried several clustering algorithms and finally used Dirichlet Process Mixture Models (DPMM) to locate and Gibbs sampling algorithm to estimate the number.
(VE 414: Bayesian Analysis)
Applied Regression Analysis
Predicting Tesla’s Closing Price
Using R, we applied ARIMA, GARCH, Hidden Markov Model (HMM) and Long Short-Term Memory (LSTM) Network Model to analyze and forecast Tesla’s closing price on 5 trading days.
(VE 406: Applied Regression Analysis using R)
Electronic Design Automation
Effective Rewriting Strategy for Digital Circuit Optimization
Our effective rewriting strategy for digital circuit optimization reduced the circuit area by 15%, using Simulated Annealing. We also created a convenient user interface.
(VE 450: Major Design Experience)
Sampling
Analysis of JJF 1070-2005 Package Contents Sampling Plan
According to the rules of quantitative packaged goods, we made detailed sampling plan, calculated the probabilities and analysis the application.
(VE 401: Probabilistic Methods in Engineering)
Probability Analysis
Police Shootings in the United States
We discussed the pattern of the occurrence of fatal police shootings in the United States, found the data distribution, derived Nelson’s formula and made prediction.
(VE 401: Probabilistic Methods in Engineering)


View Highscores
Time left:
JavaScript Quiz
Click the start button to begin the quiz!
Start game
All done!
Your final score is:
Add your score to the leaderboard:
Name
Score
Clear Highscores
Restart Game


| |
Class methods defined here:
- elCommandToOpenFirewallPort(cls, port) from __builtin__.classobj
- Build command to open a firewall port.
Only if not recognizably open yet.
As implemented copies /etc/sysconfig/iptables line containing --dport 22 .
Must be root to succeed.
Return command to open a firewall port.
Class methods inherited from nrvr.distros.common.util.LinuxUtil:
- commandToAppendAddressNameLineToEtcHosts(cls, ipaddress, name) from __builtin__.classobj
- Build command to append an ipaddress hostname line to /etc/hosts.
Only if no line yet.
As implemented any fgrep match of name in /etc/hosts prevents addition.
Must be root to succeed.
Return command to append an ipaddress hostname line to /etc/hosts.
- commandToEnableSudo(cls, username=None) from __builtin__.classobj
- Build command to enable sudo.
As implemented in /etc/sudoers duplicates any (presumably only one) line
starting with "root " and replaces "root" with the username.
Must be root to succeed.
Return command to enable sudo.
- commandToWaitForNetworkDevice(cls, device='eth0', maxSeconds='100') from __builtin__.classobj
- Build command to wait for a network device to connect.
Only waits if not connected yet.
As implemented depends on NetworkManager tabular mode outputting "connected".
Need not be root to succeed.
device
e.g. "eth0".
maxSeconds
maximum number of seconds to wait.
Return command to wait for a network device to connect.
|


starting: any
A promise that represents the bootstrapper's startup process. It resolves when the process has finished starting.
starting: any
A promise that represents the bootstrapper's startup process. It resolves when the process has finished starting.


--- layout: default permalink: /cv/ title: CV search_exclude: true --- If you are not redirected automatically, follow this link for my CV.


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/Character.20encoding.20of.20VM.html ---
Does anyone know the internal character encoding of strings after a to_char_buffer? It seems to not be UTF-8.
init.data.string.basic
says that it is
char
is a Unicode code point, so a char_buffer
is not encoded at all
I think there is a serious problem in fs_write() in vm_io.cpp in the frozen final version of Lean 3.
Inside, there is a static_cast to <unsigned char>, which is just wrong when the passed char_buffer has some multibyte unicode characters.
The effect is that nonsense is written by io.fs.write when a char_buffer containing a character such as "𝟙" is passed. e.g. when you execute the following lean program the single byte 0xD9 is written.
def write_file (fn : string) (cnts : string) (mode := io.mode.write) : io unit := do h ← io.mk_file_handle fn io.mode.write, io.fs.write h cnts.to_char_buffer, io.fs.close h def main : io unit := do write_file "test.txt" "𝟙"
I'm sure the fix won't be a big deal. Does anyone know of a workaround in the meantime?
Hmm, perhaps a char_buffer
is supposed to be encoded in UTF-8 then after all. In that case, the bug is in buffer.append_string
, which you could reimplement to do proper UTF-8 encoding
It looks to me like every time the vm needs to turn an honest std::string into a list of chars it does a utf8_decode (on purpose) to make sure a "char" is a single unicode character, so because char_buffer = buffer char I think that would be breaking the rules!
I would expect that fs_write should call some variant of push_unicode_scalar which pushes char into the temporary buffer it is building. Do you think it'd be okay if I made it do that?
Do you really want to change the Lean binary instead of fixing the issue in Lean code? This also won't work for fs_read
since reading a fixed amount of bytes does not necessarily result in a correctly terminated UTF-8 string.
I suppose you are right. But certainly the current behaviour is broken. It seems that there is some confusion as to whether a char_buffer
should morally be a buffer of characters of text, or of bytes. Much effort is currently gone to to ensure that a char
is a text-character, so that things like string.length can be the length of the underlying list of chars, etc.
I suppose in an ideal world io.fs.write would produce a buffer byte
, and io.fs.read should return such a buffer (of course the latter of these actually happens currently, but everything is still called a char
). And there would be char_buffer.decode
or something.
One can only dream!
Yes, it should look pretty much like this in Lean 4 :)
Hi again @Sebastian Ullrich sorry to resurrect this thread
At the original time of this thread I implemented the UTF-8 decoding you suggested, and we began to use it:
https://github.com/khoek/lean-tidy/blob/1fb088df379285f1d9cd303b129331f60c097fd9/src/tidy/lib/utf8.lean#L17
However we found that the decoder was slowing down the tactic it was part of (part of the visualizer for rewrite_search
, so we just dropped labels altogether
However, now coming back to caching work for lean I'm having to serialize very large buffers of unicode characters to disk, to preserve the symbols in the names typed in various files, and the slowness has reared its head once again; encoding and saving an 11mb character buffer to disk takes under 1 second if I let lean corrupt it when writing normally, or more than five minutes (I didn't let it finish) if I map the UTF-8 decoder over it. Moreover, it's not the decoder implementation being slow---just asking that each char
be replaced by its nat
value as a string via mapping char.val
over it (and trying to be efficient, appending each resulting char
one-at-a-time and not doing list joins) takes this long too.
In comparison, parsing such a buffer into the expr
it represents takes milliseconds.
This makes me very sad---would you at all consider merging a patch to lean which by default transcodes UTF-8 characters when reading and writing, when the file stream was opened in non-binary mode? The patch is under 100 lines. We address your fs_read
problem above by reading the UTF-8 characters, making the length argument a number of UTF-8 characters, not just bytes (and again, this would only be in non-binary mode).
I see. Do you have the patch somewhere?
I'll extract a nice commit for you
@Sebastian Ullrich Sorry about the delay, here you go:
https://github.com/khoek/klean/commit/7d7abf9064297cd34186fad4a043fb7229bed9e8
I've stress-tested the read/write io calls on 100mb of utf8 nonsense, and everything was reproduced correctly without crashing
Exciting! (especially if you know what comes next :-)
@Sebastian Ullrich Sorry to keep bugging you
I have a tiny little puzzle you might be interested in. If you clone https://github.com/khoek/leandemo-for-sebastian and run lean --make test.lean
(a program which just reads the accompanying file in the repo into memory) lean will finish executing essentially instantly.
On the other hand, try opening up test.lean
in vscode. I observe a multiple-second pause when lean reads in the file in "interactive mode". Why could this discrepancy be happening?
I measure less than 100ms in the first case
Are you sure it's actually rebuilding the file?
$ time lean +3.4.1 test.lean running done 0.93user 0.58system 0:04.35elapsed 34%CPU (0avgtext+0avgdata 176204maxresident)k 0inputs+200outputs (77major+66430minor)pagefaults 0swaps
Did you have any olean floating around Keeley?
I got embarrassed for a second, but I don't think its an olean problem
What does "rebuilding" mean Sebastian?
But on my computer at the terminal I get
running /home/khoek/code/lean/leandemo-for-sebastian/test.lean: parsing at line 145803226 done real 0m0.876s user 0m0.774s sys 0m0.100s
(I made it print the number of bytes 5803226
read in there)
But in vscode I can comfortably count one-thousand-and-one one-thousand-and-two after I perturb the file
And if you make the file bigger (more MB) then it takes longer, too
copy-and-pasting the contents of the test.dat
file a few times to get the file size up to 87mb, at the terminal it takes 1.967seconds to run, while in vscode it is more than 10
@Keeley Hoek What do you get if you use --server
like this?
echo '{"seq_num": 0, "command": "sync", "file_name": "test.lean"}' | time lean +3.4.1 --server
For me, it's about as fast after the first run (i.e. after the file cache is hot, probably)
When I run that it starts/finishes really quick without printing running
and done
, so I don't think its actually running
I made sure to delete the olean file
Ah, you should probably use -j0
to force it into serial mode. I don't even remember half of these things.
Yep that worked
14.14 seconds for the file in my repository (now updated, I made it way bigger)
2.348 from the terminal
@Sebastian Ullrich Sorry about the delay, here you go:
https://github.com/khoek/klean/commit/7d7abf9064297cd34186fad4a043fb7229bed9e8
I've stress-tested the read/write io calls on 100mb of utf8 nonsense, and everything was reproduced correctly without crashing
merged
@Keeley Hoek did you see this?
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


Make A New Walk
my_location
Starting Location
location_on
Ending Location
schedule
Starting Time
Create
send


[gecode-users] Negative table in Gecode
Peter Nightingale
pwn1 at st-andrews.ac.uk
Sat Feb 28 22:27:41 CET 2015
Hi,
Thanks for the suggestions Christian and George (did you intend to post
to the list George?). For now I have decided I need to make a release
because the previous release has a fairly serious bug. I have done
something quick and easy -- decompose into one constraint to rule out
each tuple. I should come back to this at some point.
I'm tempted to have a go at porting the MDDC and negative MDDC
propagators that I wrote for Minion. However Gecode and Minion are
different enough that I doubt it would be easy.
Pete
On 27/02/15 15:46, Christian Schulte wrote:
> Hi Pete,
>
> Yes, I have a brilliant idea: how about you implement a negative table
> constraint in Gecode! We would love it.
>
> I think you get the gist: no, there is nothing really...
>
> Cheers
> Christian
>
> --
> Christian Schulte, KTH, web.it.kth.se/~cschulte/
>
> -----Original Message-----
> From: users-bounces at gecode.org [mailto:users-bounces at gecode.org] On Behalf
> Of Peter Nightingale
> Sent: Friday, February 27, 2015 03:11 PM
> To: users at gecode.org
> Subject: [gecode-users] Negative table in Gecode
>
> Hi,
>
> I hope you're all well, and thoroughly enjoying your IJCAI reviewing!
>
> I'm working on Savile Row's Gecode (flatzinc) output -- I have a type in SR
> for negative table constraints (i.e. the tuple set represents the disallowed
> tuples). I don't see anything that looks relevant in registry.cpp.
> Obviously turning it into a positive table constraint is an exponential
> explosion.
>
> I could decompose into one constraint per tuple -- but of course this is
> horrible for propagation.
>
> Can you suggest anything better?
>
> Thanks,
> Peter
>
> _______________________________________________
> Gecode users mailing list
> users at gecode.org
> https://www.gecode.org/mailman/listinfo/gecode-users
>
>
>
More information about the users
mailing list