diff options
Diffstat (limited to 'systems/texlive/tlnet/tlpkg/tltcl/lib/tdbcodbc1.1.3')
-rw-r--r-- | systems/texlive/tlnet/tlpkg/tltcl/lib/tdbcodbc1.1.3/pkgIndex.tcl | 14 | ||||
-rw-r--r-- | systems/texlive/tlnet/tlpkg/tltcl/lib/tdbcodbc1.1.3/tdbcodbc.tcl | 515 | ||||
-rwxr-xr-x | systems/texlive/tlnet/tlpkg/tltcl/lib/tdbcodbc1.1.3/tdbcodbc113.dll | bin | 314312 -> 0 bytes |
3 files changed, 0 insertions, 529 deletions
diff --git a/systems/texlive/tlnet/tlpkg/tltcl/lib/tdbcodbc1.1.3/pkgIndex.tcl b/systems/texlive/tlnet/tlpkg/tltcl/lib/tdbcodbc1.1.3/pkgIndex.tcl deleted file mode 100644 index f672dd7a20..0000000000 --- a/systems/texlive/tlnet/tlpkg/tltcl/lib/tdbcodbc1.1.3/pkgIndex.tcl +++ /dev/null @@ -1,14 +0,0 @@ -# Index file to load the TDBC ODBC package. - -if {![package vsatisfies [package provide Tcl] 8.6-]} { - return -} -if {[package vsatisfies [package provide Tcl] 9.0-]} { - package ifneeded tdbc::odbc 1.1.3 \ - "[list source [file join $dir tdbcodbc.tcl]]\;\ - [list load [file join $dir tcl9tdbcodbc113.dll] [string totitle tdbcodbc]]" -} else { - package ifneeded tdbc::odbc 1.1.3 \ - "[list source [file join $dir tdbcodbc.tcl]]\;\ - [list load [file join $dir tdbcodbc113.dll] [string totitle tdbcodbc]]" -} diff --git a/systems/texlive/tlnet/tlpkg/tltcl/lib/tdbcodbc1.1.3/tdbcodbc.tcl b/systems/texlive/tlnet/tlpkg/tltcl/lib/tdbcodbc1.1.3/tdbcodbc.tcl deleted file mode 100644 index 0b19a4b891..0000000000 --- a/systems/texlive/tlnet/tlpkg/tltcl/lib/tdbcodbc1.1.3/tdbcodbc.tcl +++ /dev/null @@ -1,515 +0,0 @@ -# tdbcodbc.tcl -- -# -# Class definitions and Tcl-level methods for the tdbc::odbc bridge. -# -# Copyright (c) 2008 by Kevin B. Kenny -# See the file "license.terms" for information on usage and redistribution -# of this file, and for a DISCLAIMER OF ALL WARRANTIES. -# -# RCS: @(#) $Id: tdbcodbc.tcl,v 1.47 2008/02/27 02:08:27 kennykb Exp $ -# -#------------------------------------------------------------------------------ - -package require tdbc - -::namespace eval ::tdbc::odbc { - - namespace export connection datasources drivers - - # Data types that are predefined in ODBC - - variable sqltypes [dict create \ - 1 char \ - 2 numeric \ - 3 decimal \ - 4 integer \ - 5 smallint \ - 6 float \ - 7 real \ - 8 double \ - 9 datetime \ - 12 varchar \ - 91 date \ - 92 time \ - 93 timestamp \ - -1 longvarchar \ - -2 binary \ - -3 varbinary \ - -4 longvarbinary \ - -5 bigint \ - -6 tinyint \ - -7 bit \ - -8 wchar \ - -9 wvarchar \ - -10 wlongvarchar \ - -11 guid] -} - -#------------------------------------------------------------------------------ -# -# tdbc::odbc::connection -- -# -# Class representing a connection to a database through ODBC. -# -#------------------------------------------------------------------------------- - -::oo::class create ::tdbc::odbc::connection { - - superclass ::tdbc::connection - - variable statementSeq typemap - - # The constructor is written in C. It takes the connection string - # as its argument It sets up a namespace to hold the statements - # associated with the connection, and then delegates to the 'init' - # method (written in C) to do the actual work of attaching to the - # database. When that comes back, it sets up a statement to query - # the support types, makes a dictionary to enumerate them, and - # calls back to set a flag if WVARCHAR is seen (If WVARCHAR is - # seen, the database supports Unicode.) - - # The 'statementCreate' method forwards to the constructor of the - # statement class - - forward statementCreate ::tdbc::odbc::statement create - - # The 'tables' method returns a dictionary describing the tables - # in the database - - method tables {{pattern %}} { - set stmt [::tdbc::odbc::tablesStatement create \ - Stmt::[incr statementSeq] [self] $pattern] - set status [catch { - set retval {} - $stmt foreach -as dicts row { - if {[dict exists $row TABLE_NAME]} { - dict set retval [dict get $row TABLE_NAME] $row - } - } - set retval - } result options] - catch {rename $stmt {}} - return -level 0 -options $options $result - } - - # The 'columns' method returns a dictionary describing the tables - # in the database - - method columns {table {pattern %}} { - # Make sure that the type map is initialized - my typemap - - # Query the columns from the database - - set stmt [::tdbc::odbc::columnsStatement create \ - Stmt::[incr statementSeq] [self] $table $pattern] - set status [catch { - set retval {} - $stmt foreach -as dicts origrow { - - # Map the type, precision, scale and nullable indicators - # to tdbc's notation - - set row {} - dict for {key value} $origrow { - dict set row [string tolower $key] $value - } - if {[dict exists $row column_name]} { - if {[dict exists $typemap \ - [dict get $row data_type]]} { - dict set row type \ - [dict get $typemap \ - [dict get $row data_type]] - } else { - dict set row type [dict get $row type_name] - } - if {[dict exists $row column_size]} { - dict set row precision \ - [dict get $row column_size] - } - if {[dict exists $row decimal_digits]} { - dict set row scale \ - [dict get $row decimal_digits] - } - if {![dict exists $row nullable]} { - dict set row nullable \ - [expr {!![string trim [dict get $row is_nullable]]}] - } - dict set retval [dict get $row column_name] $row - } - } - set retval - } result options] - catch {rename $stmt {}} - return -level 0 -options $options $result - } - - # The 'primarykeys' method returns a dictionary describing the primary - # keys of a table - - method primarykeys {tableName} { - set stmt [::tdbc::odbc::primarykeysStatement create \ - Stmt::[incr statementSeq] [self] $tableName] - set status [catch { - set retval {} - $stmt foreach -as dicts row { - foreach {odbcKey tdbcKey} { - TABLE_CAT tableCatalog - TABLE_SCHEM tableSchema - TABLE_NAME tableName - COLUMN_NAME columnName - KEY_SEQ ordinalPosition - PK_NAME constraintName - } { - if {[dict exists $row $odbcKey]} { - dict set row $tdbcKey [dict get $row $odbcKey] - dict unset row $odbcKey - } - } - lappend retval $row - } - set retval - } result options] - catch {rename $stmt {}} - return -level 0 -options $options $result - } - - # The 'foreignkeys' method returns a dictionary describing the foreign - # keys of a table - - method foreignkeys {args} { - set stmt [::tdbc::odbc::foreignkeysStatement create \ - Stmt::[incr statementSeq] [self] {*}$args] - set status [catch { - set fkseq 0 - set retval {} - $stmt foreach -as dicts row { - foreach {odbcKey tdbcKey} { - PKTABLE_CAT primaryCatalog - PKTABLE_SCHEM primarySchema - PKTABLE_NAME primaryTable - PKCOLUMN_NAME primaryColumn - FKTABLE_CAT foreignCatalog - FKTABLE_SCHEM foreignSchema - FKTABLE_NAME foreignTable - FKCOLUMN_NAME foreignColumn - UPDATE_RULE updateRule - DELETE_RULE deleteRule - DEFERRABILITY deferrable - KEY_SEQ ordinalPosition - FK_NAME foreignConstraintName - } { - if {[dict exists $row $odbcKey]} { - dict set row $tdbcKey [dict get $row $odbcKey] - dict unset row $odbcKey - } - } - # Horrible kludge: If the driver doesn't report FK_NAME, - # make one up. - if {![dict exists $row foreignConstraintName]} { - if {![dict exists $row ordinalPosition] - || [dict get $row ordinalPosition] == 1} { - set fkname ?[dict get $row foreignTable]?[incr fkseq] - } - dict set row foreignConstraintName $fkname - } - lappend retval $row - } - set retval - } result options] - catch {rename $stmt {}} - return -level 0 -options $options $result - } - - # The 'prepareCall' method gives a portable interface to prepare - # calls to stored procedures. It delegates to 'prepare' to do the - # actual work. - - method preparecall {call} { - - regexp {^[[:space:]]*(?:([A-Za-z_][A-Za-z_0-9]*)[[:space:]]*=)?(.*)} \ - $call -> varName rest - if {$varName eq {}} { - my prepare \\{CALL $rest\\} - } else { - my prepare \\{:$varName=CALL $rest\\} - } - - if 0 { - # Kevin thinks this is going to be - - if {![regexp -expanded { - ^\s* # leading whitespace - (?::([[:alpha:]_][[:alnum:]_]*)\s*=\s*) # possible variable name - (?:(?:([[:alpha:]_][[:alnum:]_]*)\s*[.]\s*)? # catalog - ([[:alpha:]_][[:alnum:]_]*)\s*[.]\s*)? # schema - ([[:alpha:]_][[:alnum:]_]*)\s* # procedure - (.*)$ # argument list - } $call -> varName catalog schema procedure arglist]} { - return -code error \ - -errorCode [list TDBC \ - SYNTAX_ERROR_OR_ACCESS_RULE_VIOLATION \ - 42000 ODBC -1] \ - "Syntax error in stored procedure call" - } else { - my PrepareCall $varName $catalog $schema $procedure $arglist - } - - # at least if making all parameters 'inout' doesn't work. - - } - - } - - # The 'typemap' method returns the type map - - method typemap {} { - if {![info exists typemap]} { - set typemap $::tdbc::odbc::sqltypes - set typesStmt [tdbc::odbc::typesStatement new [self]] - $typesStmt foreach row { - set typeNum [dict get $row DATA_TYPE] - if {![dict exists $typemap $typeNum]} { - dict set typemap $typeNum [string tolower \ - [dict get $row TYPE_NAME]] - } - switch -exact -- $typeNum { - -9 { - [self] HasWvarchar 1 - } - -5 { - [self] HasBigint 1 - } - } - } - rename $typesStmt {} - } - return $typemap - } - - # The 'begintransaction', 'commit' and 'rollback' methods are - # implemented in C. - -} - -#------------------------------------------------------------------------------- -# -# tdbc::odbc::statement -- -# -# The class 'tdbc::odbc::statement' models one statement against a -# database accessed through an ODBC connection -# -#------------------------------------------------------------------------------- - -::oo::class create ::tdbc::odbc::statement { - - superclass ::tdbc::statement - - # The constructor is implemented in C. It accepts the handle to - # the connection and the SQL code for the statement to prepare. - # It creates a subordinate namespace to hold the statement's - # active result sets, and then delegates to the 'init' method, - # written in C, to do the actual work of preparing the statement. - - # The 'resultSetCreate' method forwards to the result set constructor - - forward resultSetCreate ::tdbc::odbc::resultset create - - # The 'params' method describes the parameters to the statement - - method params {} { - set typemap [[my connection] typemap] - set result {} - foreach {name flags typeNum precision scale nullable} [my ParamList] { - set lst [dict create \ - name $name \ - direction [lindex {unknown in out inout} \ - [expr {($flags & 0x06) >> 1}]] \ - type [dict get $typemap $typeNum] \ - precision $precision \ - scale $scale] - if {$nullable in {0 1}} { - dict set list nullable $nullable - } - dict set result $name $lst - } - return $result - } - - # Methods implemented in C: - # init statement ?dictionary? - # Does the heavy lifting for the constructor - # connection - # Returns the connection handle to which this statement belongs - # paramtype paramname ?direction? type ?precision ?scale?? - # Declares the type of a parameter in the statement - -} - -#------------------------------------------------------------------------------ -# -# tdbc::odbc::tablesStatement -- -# -# The class 'tdbc::odbc::tablesStatement' represents the special -# statement that queries the tables in a database through an ODBC -# connection. -# -#------------------------------------------------------------------------------ - -oo::class create ::tdbc::odbc::tablesStatement { - - superclass ::tdbc::statement - - # The constructor is written in C. It accepts the handle to the - # connection and a pattern to match table names. It works in all - # ways like the constructor of the 'statement' class except that - # its 'init' method sets up to enumerate tables and not run a SQL - # query. - - # The 'resultSetCreate' method forwards to the result set constructor - - forward resultSetCreate ::tdbc::odbc::resultset create - -} - -#------------------------------------------------------------------------------ -# -# tdbc::odbc::columnsStatement -- -# -# The class 'tdbc::odbc::tablesStatement' represents the special -# statement that queries the columns of a table or view -# in a database through an ODBC connection. -# -#------------------------------------------------------------------------------ - -oo::class create ::tdbc::odbc::columnsStatement { - - superclass ::tdbc::statement - - # The constructor is written in C. It accepts the handle to the - # connection, a table name, and a pattern to match column - # names. It works in all ways like the constructor of the - # 'statement' class except that its 'init' method sets up to - # enumerate tables and not run a SQL query. - - # The 'resultSetCreate' class forwards to the constructor of the - # result set - - forward resultSetCreate ::tdbc::odbc::resultset create - -} - -#------------------------------------------------------------------------------ -# -# tdbc::odbc::primarykeysStatement -- -# -# The class 'tdbc::odbc::primarykeysStatement' represents the special -# statement that queries the primary keys on a table through an ODBC -# connection. -# -#------------------------------------------------------------------------------ - -oo::class create ::tdbc::odbc::primarykeysStatement { - - superclass ::tdbc::statement - - # The constructor is written in C. It accepts the handle to the - # connection and a table name. It works in all - # ways like the constructor of the 'statement' class except that - # its 'init' method sets up to enumerate primary keys and not run a SQL - # query. - - # The 'resultSetCreate' method forwards to the result set constructor - - forward resultSetCreate ::tdbc::odbc::resultset create - -} - -#------------------------------------------------------------------------------ -# -# tdbc::odbc::foreignkeysStatement -- -# -# The class 'tdbc::odbc::foreignkeysStatement' represents the special -# statement that queries the foreign keys on a table through an ODBC -# connection. -# -#------------------------------------------------------------------------------ - -oo::class create ::tdbc::odbc::foreignkeysStatement { - - superclass ::tdbc::statement - - # The constructor is written in C. It accepts the handle to the - # connection and the -primary and -foreign options. It works in all - # ways like the constructor of the 'statement' class except that - # its 'init' method sets up to enumerate foreign keys and not run a SQL - # query. - - # The 'resultSetCreate' method forwards to the result set constructor - - forward resultSetCreate ::tdbc::odbc::resultset create - -} - -#------------------------------------------------------------------------------ -# -# tdbc::odbc::typesStatement -- -# -# The class 'tdbc::odbc::typesStatement' represents the special -# statement that queries the types available in a database through -# an ODBC connection. -# -#------------------------------------------------------------------------------ - - -oo::class create ::tdbc::odbc::typesStatement { - - superclass ::tdbc::statement - - # The constructor is written in C. It accepts the handle to the - # connection, and (optionally) a data type number. It works in all - # ways like the constructor of the 'statement' class except that - # its 'init' method sets up to enumerate types and not run a SQL - # query. - - # The 'resultSetCreate' method forwards to the constructor of result sets - - forward resultSetCreate ::tdbc::odbc::resultset create - - # The C code contains a variant implementation of the 'init' method. - -} - -#------------------------------------------------------------------------------ -# -# tdbc::odbc::resultset -- -# -# The class 'tdbc::odbc::resultset' models the result set that is -# produced by executing a statement against an ODBC database. -# -#------------------------------------------------------------------------------ - -::oo::class create ::tdbc::odbc::resultset { - - superclass ::tdbc::resultset - - # Methods implemented in C include: - - # constructor statement ?dictionary? - # -- Executes the statement against the database, optionally providing - # a dictionary of substituted parameters (default is to get params - # from variables in the caller's scope). - # columns - # -- Returns a list of the names of the columns in the result. - # nextdict - # -- Stores the next row of the result set in the given variable in - # the caller's scope as a dictionary whose keys are - # column names and whose values are column values. - # nextlist - # -- Stores the next row of the result set in the given variable in - # the caller's scope as a list of cells. - # rowcount - # -- Returns a count of rows affected by the statement, or -1 - # if the count of rows has not been determined. - -} diff --git a/systems/texlive/tlnet/tlpkg/tltcl/lib/tdbcodbc1.1.3/tdbcodbc113.dll b/systems/texlive/tlnet/tlpkg/tltcl/lib/tdbcodbc1.1.3/tdbcodbc113.dll Binary files differdeleted file mode 100755 index 9d0a955adb..0000000000 --- a/systems/texlive/tlnet/tlpkg/tltcl/lib/tdbcodbc1.1.3/tdbcodbc113.dll +++ /dev/null |