lg_pod_plugin 1.1.6.6 → 1.1.7.3

data/lib/sqlite3-1.5.3-x86_64-darwin/faq/faq.md

@@ -1,431 +0,0 @@
-
-## How do I do a database query?
-### I just want an array of the rows...
-
-Use the `Database#execute` method. If you don't give it a block, it will
-return an array of all the rows:
-
-```ruby
-  require 'sqlite3'
-
-  db = SQLite3::Database.new( "test.db" )
-  rows = db.execute( "select * from test" )
-```
-
-### I'd like to use a block to iterate through the rows...
-
-Use the `Database#execute` method. If you give it a block, each row of the
-result will be yielded to the block:
-
-
-```ruby
-  require 'sqlite3'
-
-  db = SQLite3::Database.new( "test.db" )
-  db.execute( "select * from test" ) do |row|
-    ...
-  end
-```
-
-### I need to get the column names as well as the rows...
-
-Use the `Database#execute2` method. This works just like `Database#execute`;
-if you don't give it a block, it returns an array of rows; otherwise, it
-will yield each row to the block. _However_, the first row returned is
-always an array of the column names from the query:
-
-
-```ruby
-  require 'sqlite3'
-
-  db = SQLite3::Database.new( "test.db" )
-  columns, *rows = db.execute2( "select * from test" )
-
-  # or use a block:
-
-  columns = nil
-  db.execute2( "select * from test" ) do |row|
-    if columns.nil?
-      columns = row
-    else
-      # process row
-    end
-  end
-```
-
-### I just want the first row of the result set...
-
-Easy. Just call `Database#get_first_row`:
-
-
-```ruby
-  row = db.get_first_row( "select * from table" )
-```
-
-
-This also supports bind variables, just like `Database#execute`
-and friends.
-
-### I just want the first value of the first row of the result set...
-
-Also easy. Just call `Database#get_first_value`:
-
-
-```ruby
-  count = db.get_first_value( "select count(*) from table" )
-```
-
-
-This also supports bind variables, just like `Database#execute`
-and friends.
-
-## How do I prepare a statement for repeated execution?
-
-If the same statement is going to be executed repeatedly, you can speed
-things up a bit by _preparing_ the statement. You do this via the
-`Database#prepare` method. It returns a `Statement` object, and you can
-then invoke `#execute` on that to get the `ResultSet`:
-
-
-```ruby
-  stmt = db.prepare( "select * from person" )
-
-  1000.times do
-    stmt.execute do |result|
-      ...
-    end
-  end
-
-  stmt.close
-
-  # or, use a block
-
-  db.prepare( "select * from person" ) do |stmt|
-    1000.times do
-      stmt.execute do |result|
-        ...
-      end
-    end
-  end
-```
-
-
-This is made more useful by the ability to bind variables to placeholders
-via the `Statement#bind_param` and `Statement#bind_params` methods. (See the
-next FAQ for details.)
-
-## How do I use placeholders in an SQL statement?
-    
-Placeholders in an SQL statement take any of the following formats:
-
-
-* `?`
-* `?_nnn_`
-* `:_word_`
-
-
-Where _n_ is an integer, and _word_ is an alpha-numeric identifier (or
-number). When the placeholder is associated with a number, that number
-identifies the index of the bind variable to replace it with. When it
-is an identifier, it identifies the name of the corresponding bind
-variable. (In the instance of the first format--a single question
-mark--the placeholder is assigned a number one greater than the last
-index used, or 1 if it is the first.)
-
-
-For example, here is a query using these placeholder formats:
-
-
-```sql
-  select *
-    from table
-   where ( c = ?2 or c = ? )
-     and d = :name
-     and e = :1
-```
-
-
-This defines 5 different placeholders: 1, 2, 3, and "name".
-
-
-You replace these placeholders by _binding_ them to values. This can be
-accomplished in a variety of ways.
-
-
-The `Database#execute`, and `Database#execute2` methods all accept additional
-arguments following the SQL statement. These arguments are assumed to be
-bind parameters, and they are bound (positionally) to their corresponding
-placeholders:
-
-
-```ruby
-  db.execute( "select * from table where a = ? and b = ?",
-              "hello",
-              "world" )
-```
-
-
-The above would replace the first question mark with 'hello' and the
-second with 'world'. If the placeholders have an explicit index given, they
-will be replaced with the bind parameter at that index (1-based).
-
-
-If a Hash is given as a bind parameter, then its key/value pairs are bound
-to the placeholders. This is how you bind by name:
-
-
-```ruby
-  db.execute( "select * from table where a = :name and b = :value",
-              "name" => "bob",
-              "value" => "priceless" )
-```
-
-
-You can also bind explicitly using the `Statement` object itself. Just pass
-additional parameters to the `Statement#execute` statement:
-
-
-```ruby
-  db.prepare( "select * from table where a = :name and b = ?" ) do |stmt|
-    stmt.execute "value", "name" => "bob"
-  end
-```
-
-
-Or do a `Database#prepare` to get the `Statement`, and then use either
-`Statement#bind_param` or `Statement#bind_params`:
-
-
-```ruby
-  stmt = db.prepare( "select * from table where a = :name and b = ?" )
-
-  stmt.bind_param( "name", "bob" )
-  stmt.bind_param( 1, "value" )
-
-  # or
-
-  stmt.bind_params( "value", "name" => "bob" )
-```
-
-## How do I discover metadata about a query?
-  
-If you ever want to know the names or types of the columns in a result
-set, you can do it in several ways.
-
-
-The first way is to ask the row object itself. Each row will have a
-property "fields" that returns an array of the column names. The row
-will also have a property "types" that returns an array of the column
-types:
-
-
-```ruby
-  rows = db.execute( "select * from table" )
-  p rows[0].fields
-  p rows[0].types
-```
-
-
-Obviously, this approach requires you to execute a statement that actually
-returns data. If you don't know if the statement will return any rows, but
-you still need the metadata, you can use `Database#query` and ask the
-`ResultSet` object itself:
-
-
-```ruby
-  db.query( "select * from table" ) do |result|
-    p result.columns
-    p result.types
-    ...
-  end
-```
-
-
-Lastly, you can use `Database#prepare` and ask the `Statement` object what
-the metadata are:
-
-
-```ruby
-  stmt = db.prepare( "select * from table" )
-  p stmt.columns
-  p stmt.types
-```
-
-## I'd like the rows to be indexible by column name.
-
-By default, each row from a query is returned as an `Array` of values. This
-means that you can only obtain values by their index. Sometimes, however,
-you would like to obtain values by their column name.
-
-
-The first way to do this is to set the Database property `results_as_hash`
-to true. If you do this, then all rows will be returned as Hash objects,
-with the column names as the keys. (In this case, the `fields` property
-is unavailable on the row, although the "types" property remains.)
-
-
-```ruby
-  db.results_as_hash = true
-  db.execute( "select * from table" ) do |row|
-    p row['column1']
-    p row['column2']
-  end
-```
-
-
-The other way is to use Ara Howard's
-[`ArrayFields`](http://rubyforge.org/projects/arrayfields)
-module. Just `require "arrayfields"`, and all of your rows will be indexable
-by column name, even though they are still arrays!
-
-
-```ruby
-  require 'arrayfields'
-
-  ...
-  db.execute( "select * from table" ) do |row|
-    p row[0] == row['column1']
-    p row[1] == row['column2']
-  end
-```
-
-## I'd like the values from a query to be the correct types, instead of String.
-    
-You can turn on "type translation" by setting `Database#type_translation` to
-true:
-
-
-```ruby
-  db.type_translation = true
-  db.execute( "select * from table" ) do |row|
-    p row
-  end
-```
-
-
-By doing this, each return value for each row will be translated to its
-correct type, based on its declared column type.
-
-
-You can even declare your own translation routines, if (for example) you are
-using an SQL type that is not handled by default:
-
-
-```ruby
-  # assume "objects" table has the following schema:
-  #   create table objects (
-  #     name varchar2(20),
-  #     thing object
-  #   )
-
-  db.type_translation = true
-  db.translator.add_translator( "object" ) do |type, value|
-    db.decode( value )
-  end
-
-  h = { :one=>:two, "three"=>"four", 5=>6 }
-  dump = db.encode( h )
-
-  db.execute( "insert into objects values ( ?, ? )", "bob", dump )
-
-  obj = db.get_first_value( "select thing from objects where name='bob'" )
-  p obj == h
-```
-
-## How do I insert binary data into the database?
-
-Use blobs. Blobs are new features of SQLite3. You have to use bind
-variables to make it work:
-
-
-```ruby
-  db.execute( "insert into foo ( ?, ? )",
-    SQLite3::Blob.new( "\0\1\2\3\4\5" ),
-    SQLite3::Blob.new( "a\0b\0c\0d ) )
-```
-
-
-The blob values must be indicated explicitly by binding each parameter to
-a value of type `SQLite3::Blob`.
-
-## How do I do a DDL (insert, update, delete) statement?
-
-You can actually do inserts, updates, and deletes in exactly the same way
-as selects, but in general the `Database#execute` method will be most
-convenient:
-
-
-```ruby
-  db.execute( "insert into table values ( ?, ? )", *bind_vars )
-```
-
-## How do I execute multiple statements in a single string?
-    
-The standard query methods (`Database#execute`, `Database#execute2`,
-`Database#query`, and `Statement#execute`) will only execute the first
-statement in the string that is given to them. Thus, if you have a
-string with multiple SQL statements, each separated by a string,
-you can't use those methods to execute them all at once.
-
-
-Instead, use `Database#execute_batch`:
-
-
-```ruby
-  sql = <<SQL
-    create table the_table (
-      a varchar2(30),
-      b varchar2(30)
-    );
-
-    insert into the_table values ( 'one', 'two' );
-    insert into the_table values ( 'three', 'four' );
-    insert into the_table values ( 'five', 'six' );
-  SQL
-
-  db.execute_batch( sql )
-```
-
-
-Unlike the other query methods, `Database#execute_batch` accepts no
-block. It will also only ever return `nil`. Thus, it is really only
-suitable for batch processing of DDL statements.
-
-## How do I begin/end a transaction
-    
-Use `Database#transaction` to start a transaction. If you give it a block,
-the block will be automatically committed at the end of the block,
-unless an exception was raised, in which case the transaction will be
-rolled back. (Never explicitly call `Database#commit` or `Database#rollback`
-inside of a transaction block--you'll get errors when the block
-terminates!)
-
-
-```ruby
-  database.transaction do |db|
-    db.execute( "insert into table values ( 'a', 'b', 'c' )" )
-    ...
-  end
-```
-
-
-Alternatively, if you don't give a block to `Database#transaction`, the
-transaction remains open until you explicitly call `Database#commit` or
-`Database#rollback`.
-
-
-```ruby
-  db.transaction
-  db.execute( "insert into table values ( 'a', 'b', 'c' )" )
-  db.commit
-```
-
-
-Note that SQLite does not allow nested transactions, so you'll get errors
-if you try to open a new transaction while one is already active. Use
-`Database#transaction_active?` to determine whether a transaction is
-active or not.
-
-## How do I discover metadata about a table/index?
-
-## How do I do tweak database settings?

data/lib/sqlite3-1.5.3-x86_64-darwin/faq/faq.rb

@@ -1,145 +0,0 @@
-require 'yaml'
-require 'redcloth'
-
-def process_faq_list( faqs )
-  puts "<ul>"
-  faqs.each do |faq|
-    process_faq_list_item faq
-  end
-  puts "</ul>"
-end
-
-def process_faq_list_item( faq )
-  question = faq.keys.first
-  answer = faq.values.first
-
-  print "<li>"
-
-  question_text = RedCloth.new(question).to_html.gsub( %r{</?p>},"" )
-  if answer.is_a?( Array )
-    puts question_text
-    process_faq_list answer
-  else
-    print "<a href='##{question.object_id}'>#{question_text}</a>"
-  end
-
-  puts "</li>"
-end
-
-def process_faq_descriptions( faqs, path=nil )
-  faqs.each do |faq|
-    process_faq_description faq, path
-  end
-end
-
-def process_faq_description( faq, path )
-  question = faq.keys.first
-  path = ( path ? path + " " : "" ) + question
-  answer = faq.values.first
-
-  if answer.is_a?( Array )
-    process_faq_descriptions( answer, path )
-  else
-    title = RedCloth.new( path ).to_html.gsub( %r{</?p>}, "" )
-    answer = RedCloth.new( answer || "" )
-
-    puts "<a name='#{question.object_id}'></a>"
-    puts "<div class='faq-title'>#{title}</div>"
-    puts "<div class='faq-answer'>#{add_api_links(answer.to_html)}</div>"
-  end
-end
-
-API_OBJECTS = [ "Database", "Statement", "ResultSet",
-  "ParsedStatement", "Pragmas", "Translator" ].inject( "(" ) { |acc,name|
-    acc << "|" if acc.length > 1
-    acc << name
-    acc
-  } + ")"
-
-def add_api_links( text )
-  text.gsub( /#{API_OBJECTS}(#(\w+))?/ ) do
-    disp_obj = obj = $1
-
-    case obj
-      when "Pragmas"; disp_obj = "Database"
-    end
-
-    method = $3
-    s = "<a href='http://sqlite-ruby.rubyforge.org/classes/SQLite/#{obj}.html'>#{disp_obj}"
-    s << "##{method}" if method
-    s << "</a>"
-    s
-  end
-end
-
-faqs = YAML.load( File.read( "faq.yml" ) )
-
-puts <<-EOF
-<html>
-  <head>
-    <title>SQLite3/Ruby FAQ</title>
-    <style type="text/css">
-      a, a:visited, a:active {
-        color: #00F;
-        text-decoration: none;
-      }
-
-      a:hover {
-        text-decoration: underline;
-      }
-
-      .faq-list {
-        color: #000;
-        font-family: vera-sans, verdana, arial, sans-serif;
-      }
-
-      .faq-title {
-        background: #007;
-        color: #FFF;
-        font-family: vera-sans, verdana, arial, sans-serif;
-        padding-left: 1em;
-        padding-top: 0.5em;
-        padding-bottom: 0.5em;
-        font-weight: bold;
-        font-size: large;
-        border: 1px solid #000;
-      }
-
-      .faq-answer {
-        margin-left: 1em;
-        color: #000;
-        font-family: vera-sans, verdana, arial, sans-serif;
-      }
-
-      .faq-answer pre {
-        margin-left: 1em;
-        color: #000;
-        background: #FFE;
-        font-size: normal;
-        border: 1px dotted #CCC;
-        padding: 1em;
-      }
-
-      h1 {
-        background: #005;
-        color: #FFF;
-        font-family: vera-sans, verdana, arial, sans-serif;
-        padding-left: 1em;
-        padding-top: 1em;
-        padding-bottom: 1em;
-        font-weight: bold;
-        font-size: x-large;
-        border: 1px solid #00F;
-      }
-    </style>
-  </head>
-  <body>
-  <h1>SQLite/Ruby FAQ</h1>
-  <div class="faq-list">
-EOF
-
-process_faq_list( faqs )
-puts "</div>"
-process_faq_descriptions( faqs )
-
-puts "</body></html>"