RubyGems - tdiary - Versions diffs - 5.2.2 → 5.2.3 - Mend

tdiary 5.2.2 → 5.2.3

Files changed (1533) hide show

data/vendor/bundle/ruby/3.1.0/gems/sqlite3-1.4.2/faq/faq.yml DELETED Viewed

@@ -1,426 +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:
-      <pre>
-        require 'sqlite3'
-        db = SQLite3::Database.new( "test.db" )
-        rows = db.execute( "select * from test" )
-      </pre>
-  - "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:
-      <pre>
-        require 'sqlite3'
-        db = SQLite3::Database.new( "test.db" )
-        db.execute( "select * from test" ) do |row|
-          ...
-        end
-      </pre>
-  - "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:
-      <pre>
-        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
-      </pre>
-  - "I just want the first row of the result set...": >-
-      Easy. Just call Database#get_first_row:
-      <pre>
-        row = db.get_first_row( "select * from table" )
-      </pre>
-      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:
-      <pre>
-        count = db.get_first_value( "select count(*) from table" )
-      </pre>
-      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:
-    <pre>
-      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
-    </pre>
-    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 correponding 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:
-    <pre>
-      select *
-        from table
-       where ( c = ?2 or c = ? )
-         and d = :name
-         and e = :1
-    </pre>
-    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:
-    <pre>
-      db.execute( "select * from table where a = ? and b = ?",
-                  "hello",
-                  "world" )
-    </pre>
-    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:
-    <pre>
-      db.execute( "select * from table where a = :name and b = :value",
-                  "name" => "bob",
-                  "value" => "priceless" )
-    </pre>
-    You can also bind explicitly using the Statement object itself. Just pass
-    additional parameters to the Statement#execute statement:
-    <pre>
-      db.prepare( "select * from table where a = :name and b = ?" ) do |stmt|
-        stmt.execute "value", "name" => "bob"
-      end
-    </pre>
-    Or do a Database#prepare to get the Statement, and then use either
-    Statement#bind_param or Statement#bind_params:
-    <pre>
-      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" )
-    </pre>
-- "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:
-    <pre>
-      rows = db.execute( "select * from table" )
-      p rows[0].fields
-      p rows[0].types
-    </pre>
-    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:
-    <pre>
-      db.query( "select * from table" ) do |result|
-        p result.columns
-        p result.types
-        ...
-      end
-    </pre>
-    Lastly, you can use Database#prepare and ask the Statement object what
-    the metadata are:
-    <pre>
-      stmt = db.prepare( "select * from table" )
-      p stmt.columns
-      p stmt.types
-    </pre>
-- "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.)
-    <pre>
-      db.results_as_hash = true
-      db.execute( "select * from table" ) do |row|
-        p row['column1']
-        p row['column2']
-      end
-    </pre>
-    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!
-    <pre>
-      require 'arrayfields'
-      ...
-      db.execute( "select * from table" ) do |row|
-        p row[0] == row['column1']
-        p row[1] == row['column2']
-      end
-    </pre>
-- "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:
-    <pre>
-      db.type_translation = true
-      db.execute( "select * from table" ) do |row|
-        p row
-      end
-    </pre>
-    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:
-    <pre>
-      # 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
-    </pre>
-- "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:
-    <pre>
-      db.execute( "insert into foo ( ?, ? )",
-        SQLite3::Blob.new( "\0\1\2\3\4\5" ),
-        SQLite3::Blob.new( "a\0b\0c\0d ) )
-    </pre>
-    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:
-    <pre>
-      db.execute( "insert into table values ( ?, ? )", *bind_vars )
-    </pre>
-- "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:
-    <pre>
-      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 )
-    </pre>
-    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!)
-    <pre>
-      database.transaction do |db|
-        db.execute( "insert into table values ( 'a', 'b', 'c' )" )
-        ...
-      end
-    </pre>
-    Alternatively, if you don't give a block to Database#transaction, the
-    transaction remains open until you explicitly call Database#commit or
-    Database#rollback.
-    <pre>
-      db.transaction
-      db.execute( "insert into table values ( 'a', 'b', 'c' )" )
-      db.commit
-    </pre>
-    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/vendor/bundle/ruby/3.1.0/gems/sqlite3-1.4.2/lib/sqlite3/constants.rb DELETED Viewed

@@ -1,50 +0,0 @@
-module SQLite3 ; module Constants
-  module TextRep
-    UTF8    = 1
-    UTF16LE = 2
-    UTF16BE = 3
-    UTF16   = 4
-    ANY     = 5
-    DETERMINISTIC = 0x800
-  end
-  module ColumnType
-    INTEGER = 1
-    FLOAT   = 2
-    TEXT    = 3
-    BLOB    = 4
-    NULL    = 5
-  end
-  module ErrorCode
-    OK         =  0   # Successful result
-    ERROR      =  1   # SQL error or missing database
-    INTERNAL   =  2   # An internal logic error in SQLite
-    PERM       =  3   # Access permission denied
-    ABORT      =  4   # Callback routine requested an abort
-    BUSY       =  5   # The database file is locked
-    LOCKED     =  6   # A table in the database is locked
-    NOMEM      =  7   # A malloc() failed
-    READONLY   =  8   # Attempt to write a readonly database
-    INTERRUPT  =  9   # Operation terminated by sqlite_interrupt()
-    IOERR      = 10   # Some kind of disk I/O error occurred
-    CORRUPT    = 11   # The database disk image is malformed
-    NOTFOUND   = 12   # (Internal Only) Table or record not found
-    FULL       = 13   # Insertion failed because database is full
-    CANTOPEN   = 14   # Unable to open the database file
-    PROTOCOL   = 15   # Database lock protocol error
-    EMPTY      = 16   # (Internal Only) Database table is empty
-    SCHEMA     = 17   # The database schema changed
-    TOOBIG     = 18   # Too much data for one row of a table
-    CONSTRAINT = 19   # Abort due to contraint violation
-    MISMATCH   = 20   # Data type mismatch
-    MISUSE     = 21   # Library used incorrectly
-    NOLFS      = 22   # Uses OS features not supported on host
-    AUTH       = 23   # Authorization denied
-    ROW        = 100  # sqlite_step() has another row ready
-    DONE       = 101  # sqlite_step() has finished executing
-  end
-end ; end